{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:28: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "<>:28: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "<ipython-input-1-36e87a054ba9>:28: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "  if tasktype is 'regression':\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "task: regression\n",
      "Net(\n",
      "  (hidden1): Linear(in_features=10, out_features=400, bias=True)\n",
      "  (hidden2): Linear(in_features=400, out_features=400, bias=True)\n",
      "  (hidden3): Linear(in_features=400, out_features=400, bias=True)\n",
      "  (predict): Linear(in_features=400, out_features=1, bias=True)\n",
      ")\n",
      "0 training loss: tensor(21.8620, grad_fn=<MseLossBackward>) test loss: tensor(19.6877, grad_fn=<MseLossBackward>)\n",
      "10 training loss: tensor(6.4311, grad_fn=<MseLossBackward>) test loss: tensor(5.1118, grad_fn=<MseLossBackward>)\n",
      "20 training loss: tensor(1.8502, grad_fn=<MseLossBackward>) test loss: tensor(1.3755, grad_fn=<MseLossBackward>)\n",
      "30 training loss: tensor(0.5939, grad_fn=<MseLossBackward>) test loss: tensor(0.5410, grad_fn=<MseLossBackward>)\n",
      "40 training loss: tensor(0.5125, grad_fn=<MseLossBackward>) test loss: tensor(0.5418, grad_fn=<MseLossBackward>)\n",
      "50 training loss: tensor(0.4310, grad_fn=<MseLossBackward>) test loss: tensor(0.4055, grad_fn=<MseLossBackward>)\n",
      "60 training loss: tensor(0.2948, grad_fn=<MseLossBackward>) test loss: tensor(0.2869, grad_fn=<MseLossBackward>)\n",
      "70 training loss: tensor(0.2303, grad_fn=<MseLossBackward>) test loss: tensor(0.2224, grad_fn=<MseLossBackward>)\n",
      "80 training loss: tensor(0.1678, grad_fn=<MseLossBackward>) test loss: tensor(0.1665, grad_fn=<MseLossBackward>)\n",
      "90 training loss: tensor(0.1272, grad_fn=<MseLossBackward>) test loss: tensor(0.1284, grad_fn=<MseLossBackward>)\n",
      "100 training loss: tensor(0.1007, grad_fn=<MseLossBackward>) test loss: tensor(0.1034, grad_fn=<MseLossBackward>)\n",
      "110 training loss: tensor(0.0824, grad_fn=<MseLossBackward>) test loss: tensor(0.0858, grad_fn=<MseLossBackward>)\n",
      "120 training loss: tensor(0.0675, grad_fn=<MseLossBackward>) test loss: tensor(0.0712, grad_fn=<MseLossBackward>)\n",
      "130 training loss: tensor(0.0555, grad_fn=<MseLossBackward>) test loss: tensor(0.0595, grad_fn=<MseLossBackward>)\n",
      "140 training loss: tensor(0.0464, grad_fn=<MseLossBackward>) test loss: tensor(0.0504, grad_fn=<MseLossBackward>)\n",
      "150 training loss: tensor(0.0394, grad_fn=<MseLossBackward>) test loss: tensor(0.0435, grad_fn=<MseLossBackward>)\n",
      "160 training loss: tensor(0.0343, grad_fn=<MseLossBackward>) test loss: tensor(0.0385, grad_fn=<MseLossBackward>)\n",
      "170 training loss: tensor(0.0304, grad_fn=<MseLossBackward>) test loss: tensor(0.0347, grad_fn=<MseLossBackward>)\n",
      "180 training loss: tensor(0.0273, grad_fn=<MseLossBackward>) test loss: tensor(0.0315, grad_fn=<MseLossBackward>)\n",
      "190 training loss: tensor(0.0246, grad_fn=<MseLossBackward>) test loss: tensor(0.0288, grad_fn=<MseLossBackward>)\n",
      "200 training loss: tensor(0.0224, grad_fn=<MseLossBackward>) test loss: tensor(0.0265, grad_fn=<MseLossBackward>)\n",
      "210 training loss: tensor(0.0204, grad_fn=<MseLossBackward>) test loss: tensor(0.0245, grad_fn=<MseLossBackward>)\n",
      "220 training loss: tensor(0.0188, grad_fn=<MseLossBackward>) test loss: tensor(0.0228, grad_fn=<MseLossBackward>)\n",
      "230 training loss: tensor(0.0173, grad_fn=<MseLossBackward>) test loss: tensor(0.0213, grad_fn=<MseLossBackward>)\n",
      "240 training loss: tensor(0.0161, grad_fn=<MseLossBackward>) test loss: tensor(0.0200, grad_fn=<MseLossBackward>)\n",
      "250 training loss: tensor(0.0150, grad_fn=<MseLossBackward>) test loss: tensor(0.0189, grad_fn=<MseLossBackward>)\n",
      "260 training loss: tensor(0.0141, grad_fn=<MseLossBackward>) test loss: tensor(0.0179, grad_fn=<MseLossBackward>)\n",
      "270 training loss: tensor(0.0133, grad_fn=<MseLossBackward>) test loss: tensor(0.0170, grad_fn=<MseLossBackward>)\n",
      "280 training loss: tensor(0.0125, grad_fn=<MseLossBackward>) test loss: tensor(0.0162, grad_fn=<MseLossBackward>)\n",
      "290 training loss: tensor(0.0118, grad_fn=<MseLossBackward>) test loss: tensor(0.0155, grad_fn=<MseLossBackward>)\n",
      "300 training loss: tensor(0.0112, grad_fn=<MseLossBackward>) test loss: tensor(0.0148, grad_fn=<MseLossBackward>)\n",
      "310 training loss: tensor(0.0106, grad_fn=<MseLossBackward>) test loss: tensor(0.0142, grad_fn=<MseLossBackward>)\n",
      "320 training loss: tensor(0.0100, grad_fn=<MseLossBackward>) test loss: tensor(0.0136, grad_fn=<MseLossBackward>)\n",
      "330 training loss: tensor(0.0095, grad_fn=<MseLossBackward>) test loss: tensor(0.0131, grad_fn=<MseLossBackward>)\n",
      "340 training loss: tensor(0.0090, grad_fn=<MseLossBackward>) test loss: tensor(0.0125, grad_fn=<MseLossBackward>)\n",
      "350 training loss: tensor(0.0086, grad_fn=<MseLossBackward>) test loss: tensor(0.0121, grad_fn=<MseLossBackward>)\n",
      "360 training loss: tensor(0.0081, grad_fn=<MseLossBackward>) test loss: tensor(0.0117, grad_fn=<MseLossBackward>)\n",
      "370 training loss: tensor(0.0077, grad_fn=<MseLossBackward>) test loss: tensor(0.0112, grad_fn=<MseLossBackward>)\n",
      "380 training loss: tensor(0.0073, grad_fn=<MseLossBackward>) test loss: tensor(0.0108, grad_fn=<MseLossBackward>)\n",
      "390 training loss: tensor(0.0070, grad_fn=<MseLossBackward>) test loss: tensor(0.0105, grad_fn=<MseLossBackward>)\n",
      "400 training loss: tensor(0.0066, grad_fn=<MseLossBackward>) test loss: tensor(0.0101, grad_fn=<MseLossBackward>)\n",
      "410 training loss: tensor(0.0063, grad_fn=<MseLossBackward>) test loss: tensor(0.0098, grad_fn=<MseLossBackward>)\n",
      "420 training loss: tensor(0.0060, grad_fn=<MseLossBackward>) test loss: tensor(0.0095, grad_fn=<MseLossBackward>)\n",
      "430 training loss: tensor(0.0058, grad_fn=<MseLossBackward>) test loss: tensor(0.0092, grad_fn=<MseLossBackward>)\n",
      "440 training loss: tensor(0.0055, grad_fn=<MseLossBackward>) test loss: tensor(0.0089, grad_fn=<MseLossBackward>)\n",
      "450 training loss: tensor(0.0053, grad_fn=<MseLossBackward>) test loss: tensor(0.0086, grad_fn=<MseLossBackward>)\n",
      "460 training loss: tensor(0.0051, grad_fn=<MseLossBackward>) test loss: tensor(0.0084, grad_fn=<MseLossBackward>)\n",
      "470 training loss: tensor(0.0049, grad_fn=<MseLossBackward>) test loss: tensor(0.0082, grad_fn=<MseLossBackward>)\n",
      "480 training loss: tensor(0.0048, grad_fn=<MseLossBackward>) test loss: tensor(0.0082, grad_fn=<MseLossBackward>)\n",
      "490 training loss: tensor(0.0044, grad_fn=<MseLossBackward>) test loss: tensor(0.0077, grad_fn=<MseLossBackward>)\n",
      "500 training loss: tensor(0.0043, grad_fn=<MseLossBackward>) test loss: tensor(0.0076, grad_fn=<MseLossBackward>)\n",
      "510 training loss: tensor(0.0041, grad_fn=<MseLossBackward>) test loss: tensor(0.0073, grad_fn=<MseLossBackward>)\n",
      "520 training loss: tensor(0.0058, grad_fn=<MseLossBackward>) test loss: tensor(0.0088, grad_fn=<MseLossBackward>)\n",
      "530 training loss: tensor(0.0039, grad_fn=<MseLossBackward>) test loss: tensor(0.0074, grad_fn=<MseLossBackward>)\n",
      "540 training loss: tensor(0.0038, grad_fn=<MseLossBackward>) test loss: tensor(0.0068, grad_fn=<MseLossBackward>)\n",
      "550 training loss: tensor(0.0035, grad_fn=<MseLossBackward>) test loss: tensor(0.0067, grad_fn=<MseLossBackward>)\n",
      "560 training loss: tensor(0.0045, grad_fn=<MseLossBackward>) test loss: tensor(0.0081, grad_fn=<MseLossBackward>)\n",
      "570 training loss: tensor(0.0045, grad_fn=<MseLossBackward>) test loss: tensor(0.0079, grad_fn=<MseLossBackward>)\n",
      "580 training loss: tensor(0.0038, grad_fn=<MseLossBackward>) test loss: tensor(0.0066, grad_fn=<MseLossBackward>)\n",
      "590 training loss: tensor(0.0039, grad_fn=<MseLossBackward>) test loss: tensor(0.0070, grad_fn=<MseLossBackward>)\n",
      "600 training loss: tensor(0.0032, grad_fn=<MseLossBackward>) test loss: tensor(0.0063, grad_fn=<MseLossBackward>)\n",
      "610 training loss: tensor(0.0080, grad_fn=<MseLossBackward>) test loss: tensor(0.0119, grad_fn=<MseLossBackward>)\n",
      "620 training loss: tensor(0.0028, grad_fn=<MseLossBackward>) test loss: tensor(0.0063, grad_fn=<MseLossBackward>)\n",
      "630 training loss: tensor(0.0033, grad_fn=<MseLossBackward>) test loss: tensor(0.0058, grad_fn=<MseLossBackward>)\n",
      "640 training loss: tensor(0.0028, grad_fn=<MseLossBackward>) test loss: tensor(0.0060, grad_fn=<MseLossBackward>)\n",
      "650 training loss: tensor(0.0026, grad_fn=<MseLossBackward>) test loss: tensor(0.0056, grad_fn=<MseLossBackward>)\n",
      "660 training loss: tensor(0.0093, grad_fn=<MseLossBackward>) test loss: tensor(0.0141, grad_fn=<MseLossBackward>)\n",
      "670 training loss: tensor(0.0031, grad_fn=<MseLossBackward>) test loss: tensor(0.0080, grad_fn=<MseLossBackward>)\n",
      "680 training loss: tensor(0.0032, grad_fn=<MseLossBackward>) test loss: tensor(0.0067, grad_fn=<MseLossBackward>)\n",
      "690 training loss: tensor(0.0026, grad_fn=<MseLossBackward>) test loss: tensor(0.0058, grad_fn=<MseLossBackward>)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "700 training loss: tensor(0.0025, grad_fn=<MseLossBackward>) test loss: tensor(0.0053, grad_fn=<MseLossBackward>)\n",
      "710 training loss: tensor(0.0027, grad_fn=<MseLossBackward>) test loss: tensor(0.0058, grad_fn=<MseLossBackward>)\n",
      "720 training loss: tensor(0.0058, grad_fn=<MseLossBackward>) test loss: tensor(0.0074, grad_fn=<MseLossBackward>)\n",
      "730 training loss: tensor(0.0025, grad_fn=<MseLossBackward>) test loss: tensor(0.0051, grad_fn=<MseLossBackward>)\n",
      "740 training loss: tensor(0.0021, grad_fn=<MseLossBackward>) test loss: tensor(0.0050, grad_fn=<MseLossBackward>)\n",
      "750 training loss: tensor(0.0041, grad_fn=<MseLossBackward>) test loss: tensor(0.0070, grad_fn=<MseLossBackward>)\n",
      "760 training loss: tensor(0.0023, grad_fn=<MseLossBackward>) test loss: tensor(0.0056, grad_fn=<MseLossBackward>)\n",
      "770 training loss: tensor(0.0033, grad_fn=<MseLossBackward>) test loss: tensor(0.0052, grad_fn=<MseLossBackward>)\n",
      "780 training loss: tensor(0.0021, grad_fn=<MseLossBackward>) test loss: tensor(0.0049, grad_fn=<MseLossBackward>)\n",
      "790 training loss: tensor(0.0025, grad_fn=<MseLossBackward>) test loss: tensor(0.0052, grad_fn=<MseLossBackward>)\n",
      "800 training loss: tensor(0.0026, grad_fn=<MseLossBackward>) test loss: tensor(0.0061, grad_fn=<MseLossBackward>)\n",
      "810 training loss: tensor(0.0051, grad_fn=<MseLossBackward>) test loss: tensor(0.0093, grad_fn=<MseLossBackward>)\n",
      "820 training loss: tensor(0.0035, grad_fn=<MseLossBackward>) test loss: tensor(0.0064, grad_fn=<MseLossBackward>)\n",
      "830 training loss: tensor(0.0025, grad_fn=<MseLossBackward>) test loss: tensor(0.0054, grad_fn=<MseLossBackward>)\n",
      "840 training loss: tensor(0.0017, grad_fn=<MseLossBackward>) test loss: tensor(0.0047, grad_fn=<MseLossBackward>)\n",
      "850 training loss: tensor(0.0017, grad_fn=<MseLossBackward>) test loss: tensor(0.0046, grad_fn=<MseLossBackward>)\n",
      "860 training loss: tensor(0.0053, grad_fn=<MseLossBackward>) test loss: tensor(0.0107, grad_fn=<MseLossBackward>)\n",
      "870 training loss: tensor(0.0022, grad_fn=<MseLossBackward>) test loss: tensor(0.0048, grad_fn=<MseLossBackward>)\n",
      "880 training loss: tensor(0.0016, grad_fn=<MseLossBackward>) test loss: tensor(0.0052, grad_fn=<MseLossBackward>)\n",
      "890 training loss: tensor(0.0016, grad_fn=<MseLossBackward>) test loss: tensor(0.0047, grad_fn=<MseLossBackward>)\n",
      "900 training loss: tensor(0.0019, grad_fn=<MseLossBackward>) test loss: tensor(0.0046, grad_fn=<MseLossBackward>)\n",
      "910 training loss: tensor(0.0020, grad_fn=<MseLossBackward>) test loss: tensor(0.0049, grad_fn=<MseLossBackward>)\n",
      "920 training loss: tensor(0.0051, grad_fn=<MseLossBackward>) test loss: tensor(0.0078, grad_fn=<MseLossBackward>)\n",
      "930 training loss: tensor(0.0031, grad_fn=<MseLossBackward>) test loss: tensor(0.0053, grad_fn=<MseLossBackward>)\n",
      "940 training loss: tensor(0.0027, grad_fn=<MseLossBackward>) test loss: tensor(0.0053, grad_fn=<MseLossBackward>)\n",
      "950 training loss: tensor(0.0020, grad_fn=<MseLossBackward>) test loss: tensor(0.0052, grad_fn=<MseLossBackward>)\n",
      "960 training loss: tensor(0.0014, grad_fn=<MseLossBackward>) test loss: tensor(0.0054, grad_fn=<MseLossBackward>)\n",
      "970 training loss: tensor(0.0022, grad_fn=<MseLossBackward>) test loss: tensor(0.0043, grad_fn=<MseLossBackward>)\n",
      "980 training loss: tensor(0.0019, grad_fn=<MseLossBackward>) test loss: tensor(0.0049, grad_fn=<MseLossBackward>)\n",
      "990 training loss: tensor(0.0019, grad_fn=<MseLossBackward>) test loss: tensor(0.0048, grad_fn=<MseLossBackward>)\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch.utils.data as Data\n",
    "import itertools\n",
    "import pickle\n",
    "\n",
    "fo = open(\"log.txt\", \"w\")\n",
    "\n",
    "tasktype='regression'# classification\n",
    "torch.manual_seed(1)    # reproducible\n",
    "p=10\n",
    "x=torch.rand(20000,p)*2-1\n",
    "X=x.numpy()\n",
    "\n",
    "### you may select the following groundtruth as you like\n",
    "# multi 1\n",
    "# y = X[:,0]*X[:,1] + X[:,2]*X[:,3]*X[:,4]+X[:,5]*X[:,6]*X[:,7]+ X[:,8]*X[:,9] \n",
    "# multi 2\n",
    "# y = np.exp(np.abs(X[:,0]-X[:,1]))*X[:,9]+np.abs(X[:,2]*X[:,3])-(X[:,4]**2)*np.abs(X[:,5])+(X[:,6]*X[:,7])**2+X[:,8]\n",
    "# multi 3\n",
    "# y = X[:,0]*X[:,1] + np.abs(X[:,1]+X[:,2]*X[:,3])+X[:,4]*X[:,5]-X[:,5]**2*X[:,6]-np.exp(X[:,7]+ X[:,8]*X[:,9]) \n",
    "# F8 (example of node overlapping)\n",
    "y=X[:,0]*X[:,1]+2**(X[:,2]+X[:,4]+X[:,5])+2**(X[:,2]+X[:,3]+X[:,4]+X[:,6])+np.sin(X[:,6]*np.sin(X[:,7]+X[:,8]))+np.arccos(0.9*X[:,9])\n",
    "\n",
    "y=torch.from_numpy(y)\n",
    "if tasktype is 'regression':\n",
    "    print('task:',tasktype)\n",
    "    loss_func = torch.nn.MSELoss()  # this is for regression mean squared loss\n",
    "\n",
    "\n",
    "y=y.reshape(len(y),1)\n",
    "x_tr,y_tr,x_te,y_te=x[:10000,:],y[:10000,:],x[10000:,:],y[10000:,:]\n",
    "torch_dataset = Data.TensorDataset(x, y)\n",
    "BATCH_SIZE=400\n",
    "loader = Data.DataLoader(\n",
    "    dataset=torch_dataset,      \n",
    "    batch_size=BATCH_SIZE,      \n",
    "    shuffle=True,               \n",
    "    num_workers=2,              \n",
    ")\n",
    "\n",
    "\n",
    "class Net(torch.nn.Module):\n",
    "    def __init__(self, n_feature, n_hidden, n_output):\n",
    "        super(Net, self).__init__()\n",
    "        self.hidden1 = torch.nn.Linear(n_feature, n_hidden)   # hidden layer\n",
    "        self.hidden2 = torch.nn.Linear(n_hidden, n_hidden)\n",
    "        self.hidden3 = torch.nn.Linear(n_hidden, n_hidden)\n",
    "        self.predict = torch.nn.Linear(n_hidden, n_output)   # output layer\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.hidden1(x))      # activation function for hidden layer sigmoid\n",
    "        x = F.relu(self.hidden2(x))\n",
    "        x = F.relu(self.hidden3(x))\n",
    "        x = self.predict(x)             # linear output\n",
    "        return x\n",
    "\n",
    "net = Net(n_feature=p, n_hidden=400, n_output=1)     # define the network #400 1200\n",
    "print(net)  # net architecture\n",
    "\n",
    "optimizer= torch.optim.Adam(net.parameters(), betas=(0.9, 0.99))\n",
    "for t in range(1000):\n",
    "    prediction = net(x_tr)     # input x and predict based on x\n",
    "    loss = loss_func(prediction, y_tr)     # must be (1. nn output, 2. target)\n",
    "\n",
    "    optimizer.zero_grad()   # clear gradients for next train\n",
    "    loss.backward()         # backpropagation, compute gradients\n",
    "    optimizer.step()        # apply gradients\n",
    "    #print(t,'loss:',loss)\n",
    "\n",
    "    if t % 10 == 0:\n",
    "        teloss = loss_func(net(x_te), y_te)\n",
    "        print(t,'training loss:',loss,'test loss:',teloss)\n",
    "        #torch.save(net.state_dict(), 'models/net_params_'+str(t)+'.pkl') \n",
    "        string='epoch:'+str(t)+'training loss:'+str(loss)+'test loss:'+str(teloss)+'\\n'\n",
    "        fo.write(string)\n",
    "\n",
    "fo.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Detect interactions analytically. (Hessian matrix is a zero matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "detection time: 51.777947425842285\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fa1ed69f850>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "import torch\n",
    "from torch import Tensor\n",
    "from torch.autograd import Variable\n",
    "from torch.autograd import grad\n",
    "from torch import nn\n",
    "import time\n",
    "st=time.time()\n",
    "torch.manual_seed(623)\n",
    "cnt=0\n",
    "aa=0\n",
    "Hessian=torch.zeros(p,p)\n",
    "grad1=torch.zeros(1,p)\n",
    "\n",
    "for j in range(100):\n",
    "        xeval = Variable(x_tr[j,:], requires_grad=True)\n",
    "        xeval=xeval.reshape(1,p)\n",
    "        f = net(xeval)\n",
    "        x_1grad, = grad(f, xeval, create_graph=True)\n",
    "        grad1=grad1+(x_1grad)**2\n",
    "        x_2grad0, = grad(x_1grad[0,0], xeval, create_graph=True)\n",
    "\n",
    "        for i in range(p-1):\n",
    "            x_2grad1, = grad(x_1grad[0,i+1], xeval, create_graph=True)\n",
    "            x_2grad0 = torch.cat((x_2grad0, x_2grad1), dim=0)\n",
    "            cnt=cnt+1\n",
    "        Hessian=Hessian+torch.abs(x_2grad0) \n",
    "        aa=Hessian/cnt\n",
    "\n",
    "print('detection time:',time.time()-st)\n",
    "plt.matshow(np.abs(aa.detach().numpy()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Detect interactions Numerically (brute force, pull each arm 100 times)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_hot(i,p):\n",
    "    '''\n",
    "    generate a p-dimensional one_hot vector, i-th element is 1\n",
    "    '''\n",
    "    \n",
    "    batch_size=1\n",
    "    # Dummy input that HAS to be 2D for the scatter (you can use view(-1,1) if needed)\n",
    "    y = torch.LongTensor([[i]])\n",
    "    # One hot encoding buffer that you create out of the loop and just keep reusing\n",
    "    y_onehot = torch.FloatTensor(batch_size, p)\n",
    "    #print(y_onehot)\n",
    "    # In your for loop\n",
    "    y_onehot.zero_()\n",
    "    y_onehot.scatter_(1, y, 1)\n",
    "    return y_onehot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.42970871925354\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fa1ed599820>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch\n",
    "from torch import Tensor\n",
    "from torch.autograd import Variable\n",
    "from torch.autograd import grad\n",
    "from torch import nn\n",
    "import time\n",
    "st=time.time()\n",
    "torch.manual_seed(623)\n",
    "cnt=0\n",
    "aa=0\n",
    "Hessian=torch.zeros(p,p)\n",
    "Firstorder=torch.zeros(1,p)\n",
    "Firstordertemp=torch.zeros(1,p)\n",
    "Hessiantemp=torch.zeros(p,p)\n",
    "grad1=torch.zeros(1,p)\n",
    "delta=1 # h=k=1 \n",
    "\n",
    "for j in range(100):\n",
    "\n",
    "        xeval = Variable(x_tr[j,:], requires_grad=True)\n",
    "        xeval=xeval.reshape(1,p)\n",
    "\n",
    "        \n",
    "        for i in range(p):                        \n",
    "            for k in range(i):\n",
    "                f0 = net(xeval-one_hot(i,p)*delta-one_hot(k,p)*delta)\n",
    "                fi =net(xeval+one_hot(i,p)*delta-one_hot(k,p)*delta)\n",
    "                fik =net(xeval+one_hot(i,p)*delta+one_hot(k,p)*delta)\n",
    "                fk=net(xeval+one_hot(k,p)*delta-one_hot(i,p)*delta)\n",
    "                \n",
    "                Hessiantemp[i,k]=((fik-fi-fk+f0)/delta**2/4)**2\n",
    "                Hessiantemp[k,i]=Hessiantemp[i,k]\n",
    "\n",
    "        cnt=cnt+1\n",
    "        Hessian=Hessian+torch.abs(Hessiantemp) \n",
    "        aa=Hessian/cnt\n",
    "\n",
    "print(time.time()-st)\n",
    "plt.matshow(np.abs(aa.detach().numpy()))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # Graph and spectral clustering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import networkx as nx\n",
    "score=np.abs(aa.detach().numpy())\n",
    "G=nx.from_numpy_matrix(score)\n",
    "color=[]\n",
    "for i in G.edges:\n",
    "    color.append(score[i[0],i[1]])\n",
    "plt.figure(1)\n",
    "nx.draw(G, \n",
    "        with_labels=True,\n",
    "        node_size=400, \n",
    "        edge_color=color,        \n",
    "        width=3, \n",
    "        cmap=plt.cm.Dark2, \n",
    "        edge_cmap=plt.cm.Blues\n",
    "       )  \n",
    "plt.show()\n",
    "\n",
    "\n",
    "#np.max(score)*0.1\n",
    "#score[score<np.max(score)*0.1]=0\n",
    "adMatrix=score\n",
    "\n",
    "\n",
    "from sklearn.cluster import KMeans\n",
    "p=10\n",
    "k=3\n",
    "\n",
    "#score[score<np.max(score)*0.1]=0\n",
    "adMatrix=score\n",
    "aaaa=np.any(adMatrix,axis=1)\n",
    "def calLaplacianMatrix(adjacentMatrix):\n",
    "\n",
    "    # compute the Degree Matrix: D=sum(A)\n",
    "    degreeMatrix = np.sum(adjacentMatrix, axis=1)\n",
    "\n",
    "    # compute the Laplacian Matrix: L=D-A\n",
    "    laplacianMatrix = np.diag(degreeMatrix) - adjacentMatrix\n",
    "\n",
    "    # normailze\n",
    "    # D^(-1/2) L D^(-1/2)\n",
    "    sqrtDegreeMatrix = np.diag(1.0 / (degreeMatrix ** (0.5)))\n",
    "    return np.dot(np.dot(sqrtDegreeMatrix, laplacianMatrix), sqrtDegreeMatrix)\n",
    "\n",
    "def spKmeans(H,k):\n",
    "    sp_kmeans = KMeans(n_clusters=k).fit(H)\n",
    "    return sp_kmeans.labels_\n",
    "\n",
    "Laplacian=calLaplacianMatrix(adMatrix[aaaa][:,aaaa])\n",
    "x, V = np.linalg.eig(Laplacian)\n",
    "\n",
    "x = zip(x, range(len(x)))\n",
    "x = sorted(x, key=lambda x:x[0])\n",
    "\n",
    "H = np.vstack([V[:,i] for (v, i) in x[:k]]).T\n",
    "\n",
    "label111=spKmeans(H,k)\n",
    "\n",
    "nodecolormap=np.ones(p)\n",
    "nodecolormap[np.where(aaaa==False)]=range(k,k+len(np.where(aaaa==False)[0])) #nodes with degree=1\n",
    "nodecolormap[np.where(aaaa==True)]=label111\n",
    "#\n",
    "plt.figure(2)\n",
    "nx.draw(G, \n",
    "        with_labels=True,\n",
    "        node_size=400, \n",
    "        node_color=nodecolormap,\n",
    "        edge_color=color,        \n",
    "        width=3, \n",
    "        cmap=plt.cm.Dark2, \n",
    "        edge_cmap=plt.cm.Blues\n",
    "       )  \n",
    "plt.savefig('figure_name.pdf',bbox_inches='tight',dpi='figure',pad_inches=0.1) # figure_name could be multi_1,2,3\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Detecting 2-way/3-way/4-way interactions via UCB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0]\n",
      "[1]\n",
      "[2]\n",
      "[3]\n",
      "[4]\n",
      "[5]\n",
      "[6]\n",
      "[7]\n",
      "[8]\n",
      "[9]\n",
      "[0, 1]\n",
      "[0, 3]\n",
      "[0, 4]\n",
      "[0, 6]\n",
      "[1, 4]\n",
      "[1, 6]\n",
      "[2, 3]\n",
      "[2, 4]\n",
      "[2, 5]\n",
      "[2, 6]\n",
      "[3, 4]\n",
      "[3, 5]\n",
      "[3, 6]\n",
      "[4, 5]\n",
      "[4, 6]\n",
      "[5, 6]\n",
      "[6, 7]\n",
      "[6, 8]\n",
      "[6, 9]\n",
      "[7, 8]\n",
      "[0, 1, 4]\n",
      "[0, 1, 6]\n",
      "[0, 3, 4]\n",
      "[0, 3, 6]\n",
      "[0, 4, 6]\n",
      "[1, 4, 6]\n",
      "[2, 3, 4]\n",
      "[2, 3, 5]\n",
      "[2, 3, 6]\n",
      "[2, 4, 5]\n",
      "[2, 4, 6]\n",
      "[2, 5, 6]\n",
      "[3, 4, 5]\n",
      "[3, 4, 6]\n",
      "[3, 5, 6]\n",
      "[4, 5, 6]\n",
      "[6, 7, 8]\n",
      "[0, 1, 4, 6]\n",
      "[0, 3, 4, 6]\n",
      "[2, 3, 4, 5]\n",
      "[2, 3, 4, 6]\n",
      "[2, 3, 5, 6]\n",
      "[2, 4, 5, 6]\n",
      "[3, 4, 5, 6]\n",
      "[2, 3, 4, 5, 6]\n",
      "All 3-cliques:  [[0, 1, 4], [0, 1, 6], [0, 3, 4], [0, 3, 6], [0, 4, 6], [1, 4, 6], [2, 3, 4], [2, 3, 5], [2, 3, 6], [2, 4, 5], [2, 4, 6], [2, 5, 6], [3, 4, 5], [3, 4, 6], [3, 5, 6], [4, 5, 6], [6, 7, 8]]\n",
      "All 4-cliques:  [[0, 1, 4, 6], [0, 3, 4, 6], [2, 3, 4, 5], [2, 3, 4, 6], [2, 3, 5, 6], [2, 4, 5, 6], [3, 4, 5, 6]]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb4AAAEuCAYAAADx63eqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAACSf0lEQVR4nOydd1xT1/vHPwl7I0MBBQQRRCGxrVVrq9ZWq+KexYkDSNBWraPW2tpdW1tbrVbCEnCAW8RRa/3a1g7raAsBQfZeAcIKSci49/cHP1KjgoyEDO6bV/+o5J7zJDeczz3PeQaNJEkSFBQUFBQUfQS6pg2goKCgoKDoTSjho6CgoKDoU1DCR0FBQUHRp6CEj4KCgoKiT0EJHwUFBQVFn4ISPgoKCgqKPoWhpg2g6DuQJIkrOVew//Z+FNQVQE7KYWpoClNDU9Bp/z2DESQBsUwMsUwMA5oBPPp5YOOYjQgYGgAajabBd0DxNKh7TKEL0Kg8PoregNfMw/br23Gz6CaM6cYwNzLv1AJHkiSEUiEkcgkmDJ6ALyd/if4W/XvBYoquQt1jCl2BEj4KtZNSmYKgpCA0S5phY2LTrSd6kiTR0NIAS2NLxM+NB9OJqQZLKboLdY8pdAlK+CjUSkplCpaeXQqCJGBpbNnj8QQSAeg0OhIXJFILo5ZA3WMKXYMSPgq1wWvmYcrRKWiRtahkQWxDIBHA1NAU11Zco1xiGoa6xxS6CCV8FGqBJEmsSV6D34p+g62pbbuvE+QKwL/DR0ttC+RCOQwtDWHqZAq7MXYwH2Te7nX14nqMdx+Pw7MPU8EQGuJp97g+tR4Vlyo6HoQO+O7wfeKvqHtMoS6oqE4KtXAl5wpuFt2ErYltu6/h3eCh9lYtDMwMYOVjBQMzA0jqJBDkCNCU1QSXWS6w8bd54rU2Jja4WXgTP+T8gADvADW9C4qOeNo9NnUyhcN4hyf+TlgihLBQCEvP9neJ1D2mUBeU8FGoHJIksf/2fhjTjdt9UpcJZKi9XQsDCwN4hnjC0OK/r2JzYTOKjxej+mZ1u8JHo9FgbGCMfbf3YfrQ6dSOoJfpzD02HWAK0wGmT/xdYVwhAMD2Gdt256DuMYW6oBLYKVROalUqCuoKYG7UvqtS2iAFCMDMxUxJ9ADAYrAF6MZ0yIXyDucxNzJHQX0BuFVcldhN0Xk6c4/bo6W6BaIyEQytDWHp1fG5IHWPKdQBJXwUKudC1gXISXmHT+jGdsagGdAgrhBDJpQp/U5YLAQhIWDhYdHhPDQaDXJCjqSsJFWYTdEFOnOP26PunzoAgC3TFjR6x9dT95hCHVCuTgqV81fpXzA1fLKLqw0DMwP0f6U/qq5XIT8yH1beymd8Fh4WcJru9NS5TA1Ncaf0jqpMp+gknbnHT4KQEmhIbwDogO1I205dQ91jClVDCR+FSpERMuTyc2FlbPXU19qNtoORjREqLleg/t96xb8b2xnDhmHzmAv0SZgamiKbnw0ZIYMhnfo69wZduceP0pjZCEJMwNLLEkbWRp26hrrHFKqG+hZRqBS+iA8aaEp1Gduj9lYteL/wYDfKDqYjTCE3ksNQZIj6P+pRfqEcLbwW9H+l4xwuOo0OGmjgi/hUvlcv0ZV7/DAkSaL6TjWAjoNaHoW6xxSqhhI+CpUilUs79brmombwbvBg5WOFAVMGQCgUorq8GgKBAIQXAeQDpT+XgmfBA926deFrD7mhHJOnToax2FhVb4OiAySmEhS/UAwDmUGXrpPXyyEtkoJuSQfRn+jStTTQOv3doqB4GpTwUagUI4POua8EOQIAgLl7a1Sgubk5vLy8AAAyuQzFOcUQ5AhgIjKB3FYOE2MTmJmZwdzcHGZmZjAy+m+expZGXP/wOrUb6CV4zTy8dPglWJtYd+m6ymuVqDOtg/Vz1qirr0MtvxaOjo6wsnq6y5QE2envFgXF06CEj0Kl2JnZgQQJgiQ6dIWR8taCQU9KWTA0MARdRoeRoRGcXJxgOdQSYrEYIpEIjY2NqKyqBA00mJmZwdTMFKQRCSvDrp83UXSPzt7jhyFkBBrTGwE60H90fxhZG0EgEKC6uho1NTVwdHSEpeWTUxsIkgAJEnZmdqp8GxR9GEr4KFSKId0QXnZeKKov6jDHy9zVHHX36lD3bx1sn7FVCnQQ5AkgKhWBZkiDuWtraxszMzOYmZnBzq518ZNKpRAKhWgQNsCQb4jXJr+GYcOGgcFggMlkgsFgwNbWVt1vt0/S2Xv8ME2ZTZCL5LAc+l9Qi6WlJSwtLdHU1AQej4fq6uonCqBYJoa3nTcV2EKhMqhvEoXKGTtoLLJqsjpcFK2GWcHCwwLNBc3Ij8iHlY8VDC0N0VLTAkGuACCB/pP6w8DsyedIRkZGsLGxgdxYjqCXg7D1w61IT09HamoqTp48iffffx/29vYYOXIkGAwGGAwGBg8eDDqdSl1VBZ25xw9T9+//5+49IYXBysoKVlZWaGxsBI/HU+wALSxa8zjFMjFGDxqtMtspKKgi1RQqJ6UyBYtOLYK1iXWHCc6knETd33VozGhES3ULCBkBAzMDmDmbod/z/Tqs4wi0Rgk2ShpxZtGZx9rXEASB3NxccLlccLlcpKamoqmpCf7+/ood4YgRI2BmZqaS99zX6Ow9BoCWmhbkR+TD0NoQXuu9npq03tjYiOrqahgaGsLBwQEyQ9kT7zEFRXehhI9C5ZAkianHpqKkoQQWxh1XX+kJzZJmuNm44eryq52qIFJTU6MkhDk5OfDw8FC4R5lMJgYMGKA2e/WJ3rjHDQ0NqKitQD96P1x6/RKYTEr4KFQDJXwUauFy9mVsuLoBtia2aikuTJIk6sX1ODD9QLcr90skEmRmZiI1NRWpqangcrkwMjJSiCCDwYC3tzcMDakTgSfRG/e4TlyHZf2WIeV0Cjw8PMBisTBixAiVz0XRt6CEj0ItdLYfX3epF9djgvsExMyOUdmiS5IkSkpKlHaFFRUV8PX1VQghg8GAtXXXwvj1ld68xzKZDMnJyYiJiYGPjw/YbDZ8fHxUPidF34ASPgq1wWvm4bWjr0EsE+tsd+6mpiakpaUphPD+/fsYMGCAknvUzc2tz7bM6e17LJFIcP78ecTGxsLf3x8sFkuR/0lB0Vko4aNQK6mVqVhydgkIklDJwiiQCECn0ZG4IFEjwQ5yuRy5ublK7lGhUKiURjF8+HCYmna9gLOuool73NLSgjNnziA+Ph7PPfccQkJC4Onp2eO5KfoGlPBRqJ3UylQEJQVBIBHAxsSmW7sjkiRR31IPK2MrxM+N16oIPx6Pp+QezcvLw5AhQxRCyGQy4ejoqGkz1Yqm7rFIJMLp06dx7NgxjBkzBiEhIXBzc+vOW6DoQ1DCR9Er8Jp52H59O24W3oSxgTHMjcw7tTiSJAmhVAgJIcEE9wn4cvKXWl+aTCwWIyMjQyGEqampsLCwUHKPenl5wcCga7UutR1N3mOhUIgTJ04gISEB48ePR3BwMAYOHNjdt0Kh51DCR9FrkCSJH3J+wL7b+1BQVwA5KYepoSlMDU2VSl8RJAGxTAyxTAwDugE8bD2wacwmTB86XSfP0kiSRHFxsZJ7tKqqCiNGjFDsCv39/TtVs1Lb0fQ9bmpqQmJiIk6ePIlJkyZh7dq1cHZ2VsVbo9AjKOGj6HVIkgS3ioukrCTcKb2DbH42aP//Q/7/j7edN0YPGo25PnPBGMDQScHriIaGBqWgmczMTDg7Oyu5RwcNGqSz71vT97ixsRHHjh3DmTNn8Nprr2HNmjXo31+7PQUUvQclfBQaR0bIwBfxIZVLYWRgBDszuz5Xl1EmkyE7O1vJPSqVSpXco76+vjA21s3WS5q6x/X19Thy5AiSkpIQEBCAVatWwcHBQe3zUmg3lPBRUGgpVVVVSu7RgoICeHt7K/IJmUwm7O3tNW2mTsDn8xEXF4dLly5h1qxZCAoKUhQ8p+h7UMJHQaEjiEQi3L9/X7ErTEtLg5WVlZJ7dMiQIVQh7g6orq5GbGwsrl69innz5mHlypWwsbHRtFkUvQwlfBQUOgpBECgsLFRyj9bW1sLPz0/hHvXz81N0OaD4j6qqKsTExOD69etYtGgRli1bRlXk6UNQwkdBoUfU1dUhLS1N4R598OABXF1dFe7RkSNHwtnZWWeDZlRNeXk5YmJi8MsvvyAwMBBLlixptyEuhf5ACR8FhR4jlUqRlZWltCskSVLJPerj46OzQTOqoqSkBNHR0fjjjz+wdOlSBAYGwty8c70GKXQPSvgoKPoQJEmioqJCSQiLi4vh4+OjcI/6+/v32cCPoqIiREZG4u7du1i+fDkWL17cp8rP9RUo4aOg6OMIhUJF93oul4u0tDTY2dkpuUf7Wvf6/Px8REREICUlBUFBQViwYAFMTEw0bRaFiqCEj4KCQgmCIJCfnw8ul4uUlBRwuVw0NDTA399f4R4dMWJEn3AFZmdnIyIiAhkZGVi9ejXmzp3b593C+gAlfBQUFE+Fz+crdoSpqanIzs6Gu7u7UtNeJycnvQ2ayczMREREBHJycrB27VrMmjULRkZGmjaLoptQwkdBQdFlJBIJHjx4oCSGhoaGSu5Rfexen5aWhoiICBQXFyM4OBgzZszQu2LjfQFK+CgoKHoMSZIoKytTco+WlZXB19dXqVehviSLp6SkgMPhoKqqCiEhIZg2bVqfOgPVdSjho6CgUAsCgUARNJOamor09HQ4OjoquUfd3d11WjDu3bsHDoeDuro6sFgsTJ48WaffT1+BEj4KCopegSAIRff6NveoQCBQqj06YsQInUsfIEkSd+7cQXh4OIRCIdhsNl5++WVKALUYSvgoKCg0RnV1NdLS0hTu0dzcXHh6eip1pdCVdkIkSeLPP/8Eh8OBXC4Hi8XChAkT9DbgR5ehhI+CgkJraGlpQWZmplJXChMTEyX3qLe3t1YHlJAkiZs3byIiIgIGBgZgs9kYN24cJYBaBCV8FBQUWgtJkigpKVFyj1ZWVmL48OGKXaG/v79WFpgmCAK//PILOBwOLCwswGazMXr0aEoAtQBK+CgoKHSKxsZGpKenK9yjGRkZcHJyUnKPurq6ao3AEASB69evIyIiAnZ2dmCz2Xjuuec0bVafhhI+CgoKnUYulyMnJ0fJPSoWi5XSKIYPH67xkmMEQeDq1auIjIyEk5MT2Gw2Ro4cqVGb+iqU8FFQUOgdPB5PyT2an58PLy8vpV2hg4ODRmyTy+W4fPkyoqOj4ebmBjabDT8/P43Y0lfps8InI2Tgi/iQyqUwMjCCnZkdDOn6VWWCgoKiFZFIhMzMTIV7lMvlwtLSUkkIvby8ejUFQSqV4uLFi4iJicHQoUPBYrHg6+ur1jmpda+VPiN8JEkitSoVF7Iu4K/Sv5DLzwUN/50BkCDhZeeFsYPGYo7PHDAHMLXmjICCgkK1EASB4uJiJfcoj8dTdK9nMBjw9/fvlaa0EokESUlJiI2NxfDhw8FiseDt7a2Ssal178novfCRJIkrOVew//Z+FNQVQE7KYWpoClNDU9Bp/z3dESQBsUwMsUwMA5oBPPp5YOOYjQgYGtAnvggUFH2d+vp6pKWlKdyjmZmZGDhwoKL2KIPBwMCBA9W2HrS0tODs2bOIj4/HyJEjwWKx4Onp2a2xqHWvY/Ra+HjNPGy/vh03i27CmG4McyPzTt1MkiQhlAohkUswYfAEfDn5S/S30I0kWgoKCtUglUqVgmZSU1Mhl8uVutcPGzZM5W2KRCIRTp8+jWPHjuH5559HaGgo3N3dO309te49Hb0VvpTKFAQlBaFZ0gwbE5tuPb2QJImGlgZYGlsifm48mE5MNVhKQUGhC5AkiaqqKiX3aGFhIby9vZXEUFXd64VCIU6ePImEhASMGzcOwcHBcHV17fAaat3rHHopfCmVKVh6dikIkoClcc999AKJAHQaHYkLEvXyS0BBQdE9hEIh7t+/r3CPpqWlwcbGRsk96unp2aOgGYFAgMTERJw4cQITJ05EcHAwXFxcHnsdte51Hr0TPl4zD1OOTkGLrEUlN78NgUQAU0NTXFtxTW+3/xQUFD2DIAgUFhYq7Qr5fL5S93o/P79uda9vbGzE8ePHcfr0aUyePBlr167FgAEDAFDrXlfRK+EjSRJrktfgt6LfYGtq2+5rGrgNqP+3Hi3VLSBJEsZ2xrBl2qLfc/1Ao7fvGqgX12O8+3gcnn1Yrw9+KSgoVEddXZ1iR8jlcpGVlQVXV1cl96izs3On15T6+nocPXoU58+fx7Rp07Bq1Spsv7W9w3WvDWGxEPy7fIhKRZCL5DAwM4CJownsRtvB0uvJgqmP655eCd/l7MvYcHUDbE1s271B5cnlaEhrgIGFAayGWoFmRIOwUIiW6hZYDbPCwPntR22RJIl6cT0OTD+AAO8Adb4VCgoKPUUikSArK0shhikpKaDT6UruUR8fHxgZGXU4Dp/Px5EjR3D498MoZ5RjoMNAGBm2f03N7zWo/rUaBuYGsPSyhKGlIeQiOcRVYli4W6D/K0/e0enjuqc3wkeSJKYem4qShhJYGFs88TVNWU0oPVMKI1sjDF49GIbmrYmbpJxE2fkyNGU1wXmmM2yZtu3O0yxphquNK35c/qPePP1QUFBoDpIkUVFRoZRcX1JSgmHDhikV4u7Xr98Tr510eBIyyjIgbhTD1tYW9vb2j3WvaMxsRNm5Mlh4WGDQwkGgGyufOZJyEjSD9tczfVv39CZlP7UqFQV1BbA2ab9Ke1NWEwDAboydQvQAgGZAg+NERzRlNaHuXl2HwmduZI6C+gJwq7h6d+BLQUHR+9BoNLi4uMDFxQUBAa07qubmZkX3+pMnT+L999+Hvb29knt08ODB4PK4KGsug+sAV8gd5KipqUFeXh769esHOzs7GBgYgCRI8G7wQDOiwWWOy2OiB6BD0QP0b93TG+G7kHUBclLe4dOITCADABj3ezzvxsi21UUgrhRDLpbDwPTJ/b5oNBrkhBxJWUl68QWgoKDQPiwsLDBmzBiMGTMGQGvQTF5eHrhcLv7991/ExcWhsbERotEi1FvVw8jSCKampnBycoK9vf1/AmjXD2bNZpDWS2E1zAoGZgYQ5ArQUt0CmgENpi6mMB/09EAbfVv39Eb4/ir9C6aGph2+xsC8Vcyk9dLHfvfwv0lqJTAbaNbuOKaGprhTeqebllJQUFB0DTqdjqFDh2Lo0KFYsGABAKC2thbTj08HvYEOHo8HcYsYJsYmMDM3g4WFBWxsbFDfUA9eCg+EjICBhQEKYgrQwmtRGtvczRwD5w+EoUXHcqBP655eCJ+MkCGXnwsrY6sOX2fpZYnG+42ovV0L6+HWMDBrFUKSIFF9s1rxOrlY3uE4poamyOZnQ0bI+mSBVwoKCs1j088GdbQ6DOw/EHQaHSRJQiwWQygUorGxEUKhEDQaDYYyQ4jkIlT+WQkTOxO4LnGFxSALSBukqLpeheb8ZpSdK4P7io6rw+jTuqfb1v8/fBEfNNCUatA9Cevh1mhIb0BzXjPyIvJg5W0FuhEdzQXNkNRJYGxnDAlfAjzl7JZOo4MGGvgivl7ltlBQUOgOj657NBoNZmZmMDP7z1slkUhQkV2BFoMWyAk5JM9IkFOfAy8HL1g7WmPQwkHI4+RBWCyEsFTYodtTn9Y9vRA+qfxx1+WToNFpcF3sCv4dPhrSG9CQ1gAZIYPcRg7DlwwhvicGKSZRVFkEekvHIio3lGPy1MkwFqu2Th8FBQVFZ5CYSlD8QjEMZE+ORyBJEgRBQCaQQS6VAxYALAGQQF5eHkaOHAm6ER2WnpaoT6mHuFz81PM+GmidXm+1Gb0QPiODjvNdHoZGp8F+rD3sx9or/TshJZD9ezZgBfiM8XlqlFNjSyOuf3hd5598KCgodBNeMw8vHX4J1ibWCjenSCSCUCiESCQCAJiZmUHiIkHD/QYYmBvAwNQARkZGEIlEaGxshI2NDeimrQ/5hIx46pwkyC6tt9qKXgifnZkdSJAgSOKp7s72aEhrACkjYcOwearoESQBEiTszFRTjJaCgoKiK9TV1SE9NR119XXgi/kQi/8/sMXMDFZWVug/oD/EIjFqamoAR8DA0ABEIwErUyvY2tmirKwMtbW1sLGxQUt1a7CLsW3H3it9Wvf0QvgM6YbwsvNCUX0RzI063qrLW+QwMFF2DYjKRaj+pRp0YzocXnJ46nximRjedt46f8BLQUGh/Txc/7Ot2kttbS38/f0xYOAANPdrhpulm6IQdlNTE8pKywAA/fv3h1QqRbNrMwxLDSH8W4jBiwajsrISAFB9vxrN+c2gm9Jh4fnkwh9t6NO6p/vv4P8ZO2gssmqynip8xQnFoBvSYdLfBHRjOlqqWyDIE4BmQMOgBYOemOP3KGKZGKMHjVaV6RQUFBQKntTxwdraGkwmE0wmE0uXLsWQIUNAp9Px0a8fIT4lHnQ6HQKBANXVrdHpjo6OsLS0BJ/PB5/Px5B5Q5Afmw8ik0DxsWJI6VIY041RnlUOYxNjOAc4t5u73IY+rXt6U7IspTIFi04tgrWJdYdJ7LW3atGY0QhJvQSklIShlSEsPCxgP87+qVt9oPXAuFHSiDOLzuhFIicFBYXmaOvxx+VyFSXLHu3xx2AwYG9v/8Tr/634F7OPzoawXgiSIOHo6Agrq9a0rpqaGjQ0NMDNzQ2gAfmZ+bCusEZzTjOaeE0wtzGHxFKCQZMHoZ/n4+XQHrVTn9Y9vdnxMQcw4dHPo8NanQBg/4I97F948peoMwilQnjaeoIxgNHtMSgoKPomMpkM2dnZSm5LqVSqELlp06Z1uqv7vXv3EM4Jh8RWAgtHC/Tv91+gXXV1NRobG+Hu7g5DQ0NUVVXBtr8tBvgPAF4DMjMz4ePrAz6fj2ZhM/qhY+HTt3VPb4SPRqNh45iN2HB1A8xJc7UUUiVJEhK5BBvHbNSLQq0UFBTqpaGhQVF4OjU1FZmZmXBxcQGTycRLL72EdevWYdCgQV1aT1JSUsDhcFBVVYWQkBDMHTIXm37cBJIkQaPRwOPxIBAI4D7YHYYGhpDL5WhoaICnp+djY9na2qKmpgYSiaRdsdXHdU9vhA8AAoYG4EzmmU71peoODS0NmDh4IqYPna7ysSkoKHQbkiRRVFSk5Lbk8Xjw8/MDk8nE6tWr4efnp3BFdpW0tDRwOByUlJQgODgYM2bMaC1CTZI49+Acfiv6DeL61pQGd3d3RYeGuro6WFpawtDw8eWeTqejX79+qK2thbOz8xPn1cd1T2/O+NrgNfPw2tHXIJaJqU7EFBQUakMsFiMjI0PJbWlpaak4lxs5ciSGDBnyWIugrpKRkYGIiAjk5uZi7dq1mDVr1mO9+iqbKjHym5EQSUQY4jpEEeFJkiRycnPg7uYOExMTxeszMzPh6+sLAJDL5cjLy4Onp+dj4qiv657eCR8ApFamYsnZJSBIQiXiJ5AIQKfRkbggUS8OdikoKLoOj8dTErn8/HwMGTJEEW3JYDDg6Oiosvmys7MRERGBjIwMrF69GnPnzn2iO1Iul+PDDz/Eg7oHSPNJA2hQrHt1dXUQCARwdXVVuuZh4QOAyspK0Ol09O//n7jp87qnl8IHtIpfUFIQBBIBbExsuuWbJkkS9S31sDK2QvzceL27+RQUFE9GLpcjJydHyW0pEomURG748OFKuyhVkZ+fDw6Hg9TUVKxatQrz589vdx6pVIqdO3dCJBLh66+/xoO6B0rrXl5+HlycXWBurpzm9ajwSaVSFBQUwMvLCzQaTe/XPb0VPqDV7bn9+nbcLLwJYwNjmBt1LuiFJEkIpUJICAkmuE/Al5O/1KttPgUFhTKNjY2Kxq9cLhf379+Hk5OTktvS1dVVrcEdhYWFiIyMxL1797BixQosWrQIpqbtt1qTSCTYvn076HQ6du/erdgNtq17VzOvQtgkhJeb12N2Pyp8AFBaVgq6MR1mVmZ6v+7ptfABrSL2Q84P2Hd7HwrqCiAn5TA1NIWpoalSeTOCJCCWiSGWiWFAN4CHrQc2jdmE6UOn600kEwUFReuaUFJSouS2rKyshK+vr2JH5+/vD2tr616xp6SkBFFRUbh16xaWLl2K119//bEd2qOIxWJs2bIF1tbW+OSTTx47myMIAq+GvQrBCAHqUf/YutcmfA+ve4SMgKBUgMMhhzHLd5Zer3t6FdX5JGg0GgK8AzB96HRwq7hIykrCndI7yOZng/b/P+T//3jbeWP0oNGY6zMXjAEMvb7xFBR9hZaWFmRmZiq5LU1MTBQiN3/+fAwdOvSJUY/qpLy8HNHR0fj111+xZMkSbN++HRYWHZcNA1oru2zatAlOTk744IMPnhg8c+/ePTjwHXB9/XWkV6c/tu7JDeVobGl8bN2L/DQSyAVow/V77dP7HV97yAgZ+CI+pHIpjAyMYGdmpxc16Cgo+jo1NTWKnRyXy0VOTg48PT0Vbksmk4kBAwZozL6qqirExMTg+vXrWLx4MZYuXdrp3WVTUxM2bNiAoUOH4p133lFEbz7K+vXrMXXqVMyePVvp39vWvclTJ+P6j9cfW/fu3r2LL774AqdPn253bH2gz670hnRDvfVfU1D0FQiCQG5urpLbUiAQKETujTfewPDhw5Was2qK6upqxMbG4urVq5g/fz7Onz8PGxubTl/f0NCA9evXY+TIkdiyZUu7HqmsrCwUFBRg+vTH8+7a1j1jsfET179Ro0bB3Nwcv/32GyZOnNj5N6dj9Fnho6Cg0D0EAgHS09MVbsv09HQ4OjqCyWRi1KhRWLNmDdzd3bVqt1JbW4v4+HhcunQJs2fPxpkzZ2Bn17XWPnw+H2FhYXjppZfwxhtvdHgMEx8fjyVLljyW69cZaDQagoKCEB8fjwkTJujtcQ8lfBQUFFoJSZIoLy9HamqqYkdXWloKX19fMBgMBAYGgsFgwNbWVtOmPpG6ujocPXoUSUlJCAgIwKlTp+Dg8PS2Z4/C4/EQFhaGqVOnIiQkpEMxKisrw+3bt7Fz585u2/3KK6/g4MGDSElJwTPPPNPtcbQZSvgoKCi0AolEggcPHihclqmpqTAwMFDkzc2ePRve3t7d2sn0Jo2NjTh27BjOnDmDqVOn4sSJE0qJ4V2hoqICYWFhmD9/PlauXPnU1x8/fhzz58/vVJBMe9DpdKxYsQJHjhyhhI+CgoJClfD5fEUB55SUFGRnZ8Pd3R1MJhOTJ0/G5s2b4eTkpDPutqamJiQkJODUqVN45ZVXcPz48XbrX3aGkpIShIWFYfny5QgMDHzq6+vq6nD16lWcPn2623O2MXPmTERGRiIvLw9Dhgzp8XjaBiV8FBQUaocgCBQUFCi5Levq6hRBKGw2G35+fk/NX9NGmpubceLECSQmJmL8+PE4cuQIBg4c2KMxCwoKsH79egQHB2P+/PmduubkyZOYPHlyu737uoKJiQlef/11HD16FB9++GGPx9M2KOGjoKBQOUKhUBGE0tZFvF+/forcuZUrV8LDw0OrglC6ilAoxOnTp3Hs2DGMHTsWhw8fbm362kOys7OxYcMGbNiwAQEBAZ225cyZMzh8+HCP529j4cKFmDt3LqqqqjSa/qEOKOGjoKDoESRJoqKiQsltWVxcDB8fHzCZTCxcuBAfffRRlyMZtRWxWIyzZ88iPj4eo0aNQmRkJDw8PFQydkZGBjZt2oRt27ZhypQpnb7uwoULePbZZ1UivG1YW1tj1qxZOH78ODZv3qyycbUBSvgoKCi6hFQqVXQRb3NbyuVyjBw5sstdxHUJiUSCc+fOIS4uDgwGA4cOHYKXl5fKxudyudiyZQvee++9LuXQyWQyHD9+HHv27FGZLW0sW7YMgYGBCA4O7rUSbr0BJXwUFBQdUl9fr9RF/MGDBxg0aBCYTCYmTpyIDRs2wMXFRWeCULqKRCJBcnIyDh8+jGHDhmH//v3w8fFR6Rx///033nnnHXz88cd44YUXunTttWvXMGjQIAwfPlylNgFA//79MWHCBJw5cwZr1qxR+fiaghI+CgoKBQRBoLCwUMltWVtbq+giHhwcDD8/vx6Fy+sKMpkMly5dQkxMDDw8PPD111+rRVxu3bqF999/H1988QVGjRrVpWtJksSRI0ewYcMGldvVxsqVK8Fms7Fs2TK1tGHSBJTwUVD0YUQikaKLeFsQipWVlSJ3LjAwEF5eXjodhNJV5HI5fvjhB0RFRWHgwIH47LPPwGAw1DLXzZs38cknn2Dv3r1gMrve9+7PP/8EnU7v8i6xK3h6esLPzw+XLl3CggUL1DZPb9Jni1RTUPRFqqqqlM7mCgoKMHToUIXQMRiMblUX0QcIgsCPP/6IqKgoODg4gM1m49lnn1XbfNevX8eePXuwb9++bu8kQ0NDMX/+fEybNq1L140aNQr37t3r9OtTUlLw4Ycf4ty5c3rxEETt+Cgo9BSZTIbs7Gwlt6VUKlV0KNi6dSt8fX31LgilqxAEgf/973+IjIyElZUVduzYgVGjRqn1zPLKlSvYv38/Dh48CG9v726NkZ6ejoqKii5Ff3aXkSNHws7ODv/73/96ZT51QwkfBYWe0NjYiLS0NMWOLjMzE87OzmAymRg3bhzYbLbau4jrEiRJ4pdffkFERASMjY2xefNmjB07Vu2fz/nz5xEVFYXw8HB4enp2e5z4+HgsX778if341MGqVasQFRWFyZMn6/x3iBI+CgodhCRJFBcXK7ktq6qqMGLECDCZTAQFBcHf3x9WVlaaNlXrIEkSv//+OzgcDoDW3nUvvfRSryzmJ0+exNGjRxEREQFXV9duj1NUVISUlBR8/PHHKrSuY1566SUcOHAAd+/exejRo3ttXnVACR8FhQ7Q0tKC+/fvK6UVmJubK9yWixcvhpeXV689/esiJEni1q1b4HA4kEgkYLFYePnll3tt93LkyBGcPXsWkZGRcHFx6dFYR48exaJFi3q1z2Bb8er4+HhK+CgoKFRPdXW1UpeCtmLBTCYTAQEBeOedd7pd8b+vQZIk7t69Cw6Hg6amJrBYLLzyyiu9FqRBkiSioqIUgTM9vW81NTW4ceMGzp07pyILO8/06dPB4XCQlZWl8lzG3oQSPgoKDSOXyxVdxNvcls3NzYq6lhs3bsTw4cNhamqqaVN1jn/++QccDgc1NTUIDQ3Fa6+91qtRiSRJ4uDBg/j9998RFRWlkrJtiYmJmD59ukb6EBoZGWHJkiWIj4/H559/3uvzqwpK+CgoepmmpiakpaUp3Jbp6ekYMGAAGAwGxowZg9DQULi5uel8AIEm4XK54HA4KCsrQ0hICKZPn97rbmCSJLF37178+++/iIiIUIlQCQQCnD9/HseOHeu5gd1k/vz5mD17NsrKynrchUJTUMJHQaFGSJJEaWmpktuyvLwcvr6+GDlyJJYuXQp/f3/Y2Nho2lS94P79+4iIiEB+fj6Cg4Mxc+ZMGBr2/jJHEAS++OIL5OTkgMPhqCzI6Ny5cxg3blyPzwh7goWFBebPn4/jx4/j7bff1pgdPYFKYKegUCESiQSZmZlKbksjIyNFgjiTyYS3t7dGFmN9JisrCxEREXjw4AHWrl2L2bNna6xTu1wux8cff4yKigrs27dPZT0GJRIJ5syZg/3793c796+NriawP0ptbS0WLVqEs2fPol+/fj2yRRNQf30UFD2gtrZWIXBcLhfZ2dnw8PAAg8HA1KlT8fbbb+tdLzNtIjc3FxEREUhLS8Pq1avxxRdfaDQhXyaT4f3330dDQwO+++47lZ7L/vDDD/Dy8uqx6KkCe3t7TJ48GSdPngSbzda0OV2G2vFRUHQSgiCQl5enELrU1FQ0NjbC399f0ZJn+PDhOtlFXNcoKChAZGQk/v77bwQFBWHBggUaD/6RSCTYsWMH5HI59uzZo1IBJggCixYtUlSV6Sk93fEBQHFxMdasWYPk5GSd+85TOz4KinZobm5Genq6wm2Znp4Oe3t7MJlMPPPMM1i1ahUGDx6sF7ULdYXi4mJERUXhr7/+wvLly7Fr165ezWVrj5aWFmzbtg2mpqb44osvVO5mvXnzJiwsLPDcc8+pdNye4ObmhmeffRYXLlzAkiVLNG1Ol6B2fBQU+K+LeEpKisJtWVJSgmHDhinO5vz9/XXyPEMfKCsrQ3R0NH777TcsWbIEgYGBWtMaSSgUYvPmzXBwcMBHH32k8uhRkiSxZs0aLF++HK+++qpKxlTFjg9o7Rj/9ttvIykpSafOrXXHUgoKFSKRSJCVlaXktgQAJpOJkSNHYubMmfDx8dFYgARFKxUVFTh8+DBu3LiB119/HefPn9eqMmwCgQAbN26Eu7s73nvvPbXs/v/99180NDRg0qRJKh+7pwwfPhyDBg3CtWvXEBAQoGlzOg0lfBR9Aj6fr1TAOSsrC25ubmAymZg0aRI2bdoEZ2dnKndOS+DxeDh8+DCuXbuGhQsX4vz587C2tta0WUo0NjbijTfewIgRI7Bt2za1ubyPHDmC5cuXa61LfeXKlfjuu+8wffp0nfn7oYSPQu9o6yL+sNuSz+fD398fDAYDLBYLfn5+Oncg3xeora1FbGwsrly5grlz52ptuHxdXR3Wr1+P0aNHY+PGjWpb8PPy8pCZmYk9e/aoZXxV8MILL+DAgQP4888/8eKLL2ranE5BCR+FziMUCnH//n2F2zItLQ02NjZgMBgYOXIkli9fDk9PT619YqZo3ZEfOXIEycnJmDlzJk6fPg17e3tNm/VEampqEBYWhldeeQVsNlutu5z4+HgEBgZqdc9EGo2GlStXIj4+XmeEjwpuodApSJJEZWWlUiWUoqIieHt7KyWJq6ImIoX6aWhowNGjR3Hu3DlMmzYNq1evhqOjo6bNapfKykqEhYVh1qxZWLNmjdrnWrp0KS5cuKDyc01VBbe0IZfLMXfuXOzevRt+fn4qG1ddUDs+Cq2mrYv4w25LmUymELlp06Zh2LBhWv1ETPE4jY2NSEhIwOnTp/Hqq68iISEBTk5OmjarQ8rKyhAWFobAwEAsXbpU7fMlJCRg9uzZWhXM0x4GBgZYvnw54uPj8dVXX2nanKdCCR+FVtHQ0KDYzXG5XGRmZmLgwIFgMBiYMGEC3njjDQwcOFBnDtEplBEIBEhMTMSJEycwceJEHD16VKN1JztLUVER1q1bh9WrV2PhwoVqn6+xsRGXLl3CiRMn1D6Xqpg9ezaio6NRVFQEd3d3TZvTIZTwUWgMgiBQVFSk5Lasrq6Gn58fmEwm1qxZAz8/P1haWmraVIoeIhQKcfLkSSQkJGDcuHGIi4vrUQfy3iQvLw/r16/HunXrMHv27F6Z8/Tp03j55Zd1queimZkZFi1ahKNHj+K9997TtDkdQgkfRa8hFouVglC4XC4sLS0VbsvAwEB4eXlRQSh6hFgsxunTp3H06FGMGjUKUVFRGDx4sKbN6jQPHjzAhg0bsGXLFkydOrVX5mxpacHJkycRERHRK/OpksWLF2P+/Plgs9lwcHDQtDntQgkfhdrg8XhKXQry8/Ph5eUFBoOB2bNnY+fOnVodyEDRfVpaWnD27FnEx8dj5MiRCA8Px5AhQzRtVpdIS0vDli1b8M477+CVV17ptXmTk5Ph5+cHDw+PXptTVdja2mLatGlITEzEm2++qWlz2oWK6qRQCXK5HNnZ2Upuy5aWFkWUJZPJhK+vL0xMTDRtKoUakUgkSEpKQlxcHHx9fcFisbSim0BX+eeff7B9+3Z8+OGHvRqiL5fLMX/+fHzyySdgMBhqm0fVUZ0PU15ejuXLlyM5OVlrjymoHR9Ft2hsbFRUQuFyucjIyICTkxOYTCZeeOEFsNlsuLq6UkEofQSpVIqLFy8iJiYGXl5e2Lt3L3x9fTVtVre4c+cO3n33XXz++ecYPXp0r879v//9Dw4ODmoVPXXj4uKCcePG4dy5c1i5cqWmzXkilPBRPBWSJFFSUqLktqysrMTw4cPBYDCwcuVK+Pn5aV1JKQr1I5fLcfnyZURHR8PNzQ1ffPEF/P39NW1Wt/n999/x0Ucf4auvvsIzzzzTq3OTJIn4+HiwWKxenVcdrFy5Ehs3btTa5HtK+Cgeo6WlBRkZGUppBaampgq35cKFCzF06FCVV6Gn0B0IgsDVq1cRFRWFAQMG4KOPPup1oVA1N27cwBdffIFvv/1WI0nYd+/ehVQqxUsvvdTrc6sab29veHl54YcffsCcOXM0bc5jUMJHgZqaGqXdXG5uLjw9PcFkMjF9+nS88847OhVWTaE+CILA9evXERkZCRsbG+zcuVMljVE1zdWrV/HNN9/gwIED8PHx0YgNcXFxWLFihd5ENQcFBWH37t2YNWuW1r0nSvj6GARBIDc3V0noBAIBGAwGGAwGNmzYAF9fX61o7kmhPRAEgV9++QUcDgfm5ubYtm0bRo8erRdnuMnJyQgPD9do5GlmZiYKCwsxbdo0jcyvDp577jlYWFjg5s2bePnllzVtjhKU8Ok5AoEAaWlpCrdleno6+vfvDwaDgeeffx7BwcFwc3PTuicyCu2AJEn89ttv4HA4MDAwwMaNGzFu3Di9EDygNVE8Li4OERERcHNz05gdR48exbJly/Sq/yONRkNQUBDi4+MxceJErfrOUMKnR5AkibKyMqXdXFlZGXx9fcFkMrFkyRL4+/vD1tZW06ZSaDkkSeLWrVvgcDiQSqVgs9mYMGGCVi1ePeX48eM4efIkIiMjMXDgQI3ZUVpaitu3b2t9tZPuMGnSJBw8eBApKSladQZMCZ8OI5FI8ODBAyWhMzAwUOTNzZ07F0OHDtWrp0gK9UKSJO7cuQMOh4Pm5mawWCxMmjRJ7zwChw8fxqVLlxTBOZrk2LFjWLBggV72h6TT6VixYgXi4+Mp4aPoHnw+XyFwqampyM7OxuDBg8FgMDBlyhRs3boVAwYM0Kuncore4++//waHwwGfzweLxcLkyZP1TvBIkkR4eDh++eUXREZGarysFp/Px48//oizZ89q1A51MnPmTERERCAvL09rqvdQwqelEASB/Px8pd1cQ0MD/P39wWQyERYWhhEjRujlUyJF75KamgoOh4OKigqEhoZi6tSpepmqQpIk9u3bh7t37yIiIkIrOrufPHkSU6ZM0ev+kcbGxggMDMSRI0fw0UcfadocAJTwaQ1CoRDp6ekKoUtPT4ednR0YDAaeeeYZrFq1CoMHD9a7J3AKzZGeng4Oh4Pi4mIEBwcjICAAhob6uSQQBIGvvvoK9+/fB4fD0YpiC0KhEGfPnkVsbKymTVE7CxYswNy5c1FZWakVfRf181uu5ZAkiYqKCiW3ZUlJCXx8fMBgMLBo0SJ88sknWvFESqF/ZGZmIiIiAjk5OVi7di1mzZql1+fABEHg008/RVFREcLDw2FhYaFpkwAASUlJGDVqlM60Z+oJ1tbWmD17NhISErB582ZNm0MVqe4NpFIpsrKylNyWBEFg5MiRipY8Pj4+Wlnah0J/yM7ORmRkJO7fv4/Vq1dj7ty5ev+dk8vl+OCDD1BTU4NvvvlGa44GZDIZ5syZg6+++grDhw/v9fnVWaS6PXg8HgIDA5GUlKTxHXev7PhkhAx8ER9SuRRGBkawM7ODIV1/N5t1dXWKAs6pqanIysqCq6srGAwGJk2ahE2bNsHZ2ZkKQqHoFfLz8xEREYGUlBQEBQXhs88+6xNdMqRSKXbu3AmxWIz9+/dr1Xv+8ccf4ebmphHR0xT9+/fHxIkTcfr0aaxdu1bpd72tEWrZ8ZEkidSqVFzIuoC/Sv9CLj8XNPy3yJMg4WXnhbGDxmKOzxwwBzB1VgQIgkBhYaGS27K2thb+/v6K2pZ+fn5a416h6DsUFRUhMjISd+/exfLly7Fo0aI+U5FHIpHg7bffhoGBAXbv3q1VO1uSJPH6669j8+bNGDt2rEZs0MSODwAKCgrAYrGQnJyMB/UPNKYRKhU+kiRxJecK9t/ej4K6AshJOUwNTWFqaAo67b+gDIIkIJaJIZaJYUAzgEc/D2wcsxEBQwO0XgBFIhHu378PLpeLlJQUpKWlwdraWpE7x2AwMGTIECoIhUJjlJSUIDo6Gn/88QeWLl2KwMBArXHx9QYikQhbtmyBra0tPv74Y60L2Pn9999x6NAhHD9+XGPrnaaEjyRJzNs+DwX9CyA0FmpMI1QmfLxmHrZf346bRTdhTDeGuZF5pwwkSRJCqRASuQQTBk/Al5O/RH8L7SmIXFlZqdSloKCgAN7e3ordHIPBgL29vabNpKBAeXk5YmJi8MsvvyAwMBBLlizR2kag6qK5uRmbNm3CwIEDsWvXLq18AA0JCcHChQsxdepUjdmgkTO+/9eI69nXUVdbBx8PH41phEqEL6UyBUFJQWiWNMPGxKZbikySJBpaGmBpbIn4ufFgOjF7alaXkclkyM7OVnJbSqVShcC1dRHXJrcJBUVVVRViYmJw/fp1LFq0CMuWLdN48IAmaGpqwptvvglvb2+88847Wil6XC4X7733Hs6fP6/RXMneFr5HNaKoqAh2dnZd+p6qUiN6LHwplSlYenYpCJKApXHPny4FEgHoNDoSFySqXfwaGxvB5XIVbsvMzEy4uLgouS0HDRqk9e5Xir5JdXU1YmNjcfXqVcybNw8rVqzos3VY6+vrsX79ejz77LPYvHmz1v7Nbt26FaNHj8bixYs1akdvCt+TNEIgEKC6uhoeHh5dHk8VGtEj4eM18zDl6BS0yFpUInptCCQCmBqa4tqKaypze5IkiaKiIsVOLjU1FTweD35+fkpBKFZWViqZj4JCXfD5fMTFxeHSpUuYNWsWgoKC9Lryx9Oora1FWFgYJkyYgPXr12ut6BUWFiI0NBTJyckwNTXVqC29JXwdaUR+fj4GDBjQrcC/nmpEt099SZLE9uvb0Sxphq2pbbuvkzZKUX2zGs15zZCL5DC0NISVjxUcXnKAgdmTt/qWxpaoF9dj+/XtODz7cLe+yGKxGBkZGQq3JZfLhbm5uWInt3jxYnh5eellaSYK/aS+vh5HjhxBUlISAgICcOrUKY3XmtQ0PB4PbDYbAQEBWLt2rdaKHtDaemjRokUaF73e4mkaYW9vj/xD+TCUPFmGDCwM4L3J+4m/66lGdFv4ruRcwc2im7A1sW33NZI6CQrjCyFvlsPS2xIm9iYQVYjAv8OHIE+AwUGD2xU/GxMb3Cy8iR9yfkCAd8BT7eHxeEpuy/z8fAwZMgRMJhMzZ87Ejh07qC7iFDpJY2Mjjh07hjNnzuC1117DiRMnqO8yWoN5wsLCsGDBAqxcuVLT5nRIdXU1fv75Z5w/f17TpvQaT9MIa2trEAQBGAMOYx5/gKMbd3xG21WNeJhuCR9Jkth/ez+M6cYdKm3l1UrIm+UY8NoA2D3/nyum6qcq8O/wwfuZB+cA5ydeS6PRYGxgjH2392H60OlK88jlcuTk5Ci5LUUikWI399Zbb2H48OFalbBKQdFVmpqakJiYiJMnT2LSpEk4duwYXFxcNG2WVlBcXIx169Zh5cqVGj8v6wyJiYkICAiAjY2Npk3pFTqjETQaDUbGRpDL5XCc4NjlOTrSiKfRLeFLrUpFQV0BrE3aj8iR1EnQnN8MI1sj9HtOueak40RH1KfUoyG9AQMmD2hX2c2NzFFQX4BbBbeASijclvfv38eAAQPAZDIxZswYhIaGws3NTavdHBQUnUUoFOLEiRNISEjA+PHjER8fj0GDBmnaLK0hPz8fb7zxBkJDQzF37lxNm/NUBAIBkpKScPz4cU2b0mt0RiMAwMjICM2SZkikEhgbdT1avk0juFXcLgW6dEv4LmRdgJyUdyg0wiIhAMDCwwI0uvLr6MZ0mA0yQ3N+M0RlIlh4KB9uSiQSiEQiCEVC1IvrseTDJZhmNg1MJhPLly+Hv79/nwzXptBvRCIRTp8+jWPHjmHMmDE4fPgw3NzcNG2WVpGdnY0333wTGzduREBA19xbmuLs2bN48cUX4ez8ZO+WPtIZjQAAGmgwohuh/FY5LA0sQTeiw6S/CczdzB/TjSdeT6NBTsiRlJWkfuH7q/QvmBp2fEDbUtsCADC2e7KKG9sZozm/GS21LaANoEEkErWKnVAIGp0GczNzmJmZwcnSCd7DvRGxPKI7plJQaD0tLS04c+YM4uPj8dxzz4HD4cDT01PTZmkdGRkZ2LRpE7Zv345XX31V0+Z0ColEgsTERBw4cEDTpvQqndGINmgSGuqu10FoIlSULTOyNYLLLBeYuz294pCpoSnulN7pkn1dFj4ZIUMuPxdWxh2H/RMtBADAwFQ5eEUmk0EkEqFZ0owWSQvKispgaW8Jc3NzWFtbY4DTABgZ/tcihSAJ5NblQkbI9LqwNUXfQyKR4Pz584iLi4Ofnx++//57DB06VNNmaSWpqanYunUr3n//fUyYMEHT5nSaK1euwNvbu0/d185qBADYMGxg7maOeqIeRqZGsDGyAf8uH/Up9Sg+UYzBQYNhOqBjATU1NEU2P7tLGtFlJeGL+KCBplRXrTM0NDSgsLAQRkZGsLCwAJ1Gh5GhEfo79YejR/sHm3QaHTTQwBfxtaqUGQVFd5FKpUhOTkZMTAx8fHzw7bffYtiwYZo2S2u5e/cuduzYgU8//VRjRZ27A0EQOHLkCHbu3KlpU3qVrmhEW1CLpE6CyspK9PftD+cAZ9CN6eDf5qPmtxoMWtjx+XZ3NKLLwieVSzv1OrpJ65uWi+UAWvPqaDQa5HI5mpubQTQQkMvlEMvFEIvFHea20EDr9LwUFNqKTCbD5cuXER0dDQ8PD3z11VcYMWKEps3Sav7880/s2rULe/bswbPPPqtpc7rEL7/8AisrK52zu6d0Za0Wi8WoqqpCXV2dUjHxfs/2A/82H8JiYafG6apGdFn4jAw616nZxL41lUDClwBo7cXU2NiI/v37o6GhAfWN9QAAwoxAeXk5pFIpTE1NYW7eerZnZmamSC4nQXZ6XgoKbUMul+OHH35AVFQUBg4ciE8//RRMZu/XotU1fv31V3z66af45ptvwGAwNG1OlyBJEvHx8QgKCupz0eadWavFYjGqq6shEolAEARMTE0waOB/OzsDi9a1n5ASnZqzqxrRZeGzM7MDCRIESXS4lTV3bz2UbC5oBkmQoNFpsLOzQ3NzMwY5DYKgUQCpgRQSKwn62/eHpaWlIsCltrYWYrEYRkZGMDEzAc2EBkG1AI7mjn3uS0ShuxAEgWvXriEyMhL29vb44IMP+tzTf3e5du0avv76a3z33Xfw9fXVtDld5t9//0VTUxNefvllTZvS63SkES0tLQrBs7W1RYukRbH2P1wuUlQqAtAa5PI0CJIACRJ2Zp0v29dl4TOkG8LLzgtF9UUwN2o/4sa4nzEsPC3QnN+Mur/rYPe8Hfr164fc3FxUcitBk9HQ/7n+sHGzQXV1NWpqauDo6AhHx//O+8RiMeqb62EiNMGGNzZALBYrtQOiktQptBGCIHDjxg1ERkbC0tIS77zzDp5//nnqoa2TXLp0CQcPHtTpYJ/4+HisWLFCKztEqJsnaUSLpAU11TVoFjbDwd4Bjo6OKEorgp2LHURykVJrN2mDFFXXqgAANn5PT/gXy8TwtvPuUvBjt8Ikxw4ai6yarA6FDwCcpjmhML4QVdeq0FzYDBMHExB5BGrKamDR3wL9J/WHgZkB3N3d0dzcrBBABwcHWFtbw9TUFMakMVaOW4kPPv4APB5PkcT+7bffIj8/H15eXmAwGBg5ciQYDEafr11IoTlIksSvv/6KiIgIGBkZYdOmTXjhhRcowesC586dQ3R0NMLDw7tVuV8byM3NRVZWFr766itNm6Ix2jTCkDRETU0NBAIB7O3t4ezsDJlMhqLiIpjUmID3Ew/yfnIYuhtCYiKBpE4CQa4ApIyEpZcl7Mc+vdepWCbG6EGju2Rft7ozpFSmYNGpRbA2sX7qH7W0UYrqX6vRnN9apJpuQYfETgLvOd4wtnw8x6+tXQVJknBwcABpTOLM4jNPTE4UiUTIzMxESkqKok6npaWlUv88Ly+vPvnURdF7kCSJP/74AxwOBwRBgM1mY/z48ZTgdZHExEQkJCTg0KFDcHV11bQ53WbXrl3w9PTEqlWrNG1Ku6i7O8M17jUsOb8EkiYJ7O3sYWdnBzqdjpaWFhQXF8PR0RHGjcYo/rUYZB0JupQOQkLAwNQApgNMYeNvA2u/p+sLSZJolDTizKIna0R7dGvHxxzAhEc/D5Q0lMDCuOOWEkbWrYmID1NRUYFGcSMcLB/fnVlaWsLS0hICgQAVNRUwl5mjMacR5ADysQ/BzMwMzz77rOLchCAIpdZDJ06cQHV1Nfz8/BRi6O/v3+e6UlOoB5Ik8ddff4HD4UAsFoPFYuHll1+mHrS6QVxcHJKSkhAZGanTFU4qKirw+++/Y9u2bZo2RSNUVFTg8OHDuP6/6+g/pT8IdwJWJq1nd+IWMUqKS9C/f3/Y2NhAaiEFfQy9R5sToVQIT1tPMAZ0Lfip2/34LmdfxoarG2BrYtvlJ1uJRILCwkIMHTq03WtJkkS9uB7BLsFIOZMCMzMzsNlsjBkzpkvz1dfXIy0tTSGGmZmZGDhwoJJ7dODAgdTTOUWXuHv3LjgcDhobGxEaGopXX32VErxuQJIkoqKicO3aNRw6dEjnu07s3bsXRkZG2LBhg6ZN6RBV7/h4PB5iY2Px448/YuHChVi+fDl+q/xNoRHiFjFKSkrg7OSsCGKpqqoCjUbr9j1v04gD0w90uTtDt4WPJEmsSV6D34p+67AfX3uUlpbCwsIC/fr1e+Lv68X1mOA+ATGzY0CSJK5fv47IyEjY2NiAzWbj+eef747ZkEqlyMnJUbhHU1NTIZfLldyjw4YNg7Fx1wumUug///77LzgcDqqrqxESEoKpU6dSgtdNSJLEgQMH8Oeff+LQoUM630y3oaEB8+bN04m2UaoSvtraWsTGxuLKlSuYO3cuVqxYoVjT2zTievZ1NFQ1wMXFReFtk8vlyMvLg6enp1L+Xld4WCO6unHpcQf2146+BrFM3OUO7CKRCGVlZfDy8nrsd+111yUIAlevXkVUVBT69+8PNpuNZ555prvmA2i9OZWVlUotjoqKiuDt7a0khrr+R0nRM7hcLjgcDkpLSxESEoKAgACqiXEPIAgCe/fuBZfLxcGDB/WiXU90dDTKy8uxa9cuTZvyVHoqfHV1dYiPj0dycjJmzpyJoKAgpcjMNq7+dhWLkhfBvr89HGz+O9qqqamBVCrttlu7px3YeyR8AJBamYolZ5eAIIkui19RURH69eun1GlBIBGATqMjcUFiu4eVcrkcV65cQVRUFFxdXcFisVSa4CoUCnH//n2FGHK5XNja2iq5Rz09Pakn/T5ARkYGOBwO8vPzERwcjJkzZ3b7CZWiFYIgsHv3buTl5WH//v1K+Vu6ilgsxuzZsxEZGYnBgwdr2pyn0l3ha2howNGjR3Hu3DlMmzYNq1atand3++eff+KDDz7A2nfX4uOMjxUaQZIkcnJz4O7uDhPjrqejdUYjnkaPhQ9oFb+gpCAIJALYmNh0etvZFsHp4eHR6q9tqYeVsRXi58Z36g3JZDJcvHgRMTEx8PT0BJvNxvDhw3v6dh6DIAgUFhYqRY/y+Xz4+/srdoR+fn4wN396JXEK3SA7OxscDgcPHjzAmjVrMHv2bMr9rQLkcjk++ugjVFZWYt++fXrzN3Pq1Cncvn0be/fu1bQpnaKrwtfY2IiEhAScPn0ar776KtasWQMnJ6d2X//zzz9j9+7d2Lt3L/z9/ZU0ghASaG5u7nLkbnc0oj1UInxAq9tz+/XtuFl4E8YGxjA3Mu+UAObl58HG3gYGJgaY4D4BX07+sstbV4lEggsXLiA2NhbDhg0Dm82Gt7d3d99Kp+Dz+UhLS1O4R7OysuDm5qbkHnV2dqaCZnSMvLw8REREgMvlYtWqVZg/fz4leCpCJpPhvffeg0AgwNdff91hfV5dQi6XY968efj00091prRaZ4WvubkZCQkJOHHiBCZOnIjg4GC4uLh0eM3DVXceLr7Oa+bh7Wtv4/Sd0+jv0B92lnadWh9JkoRQKoSEkHRbIx5FZcIHtBr4Q84P2Hd7HwrqCiAn5TA1NIWpoalS6RqCJCCWiVv/E4lh0GiAiFURXW4f/ygSiQRnz55FXFwcmEwmWCwWhgwZooq31qm5s7KyFO7RlJQU0Ol0Jfeoj48PjIyomqPaSGFhISIjI3Hv3j2sXLkSCxcu1JuFWRuQSCR45513AABffPGFXj1MXLt2DadPn0ZUVJSmTek0TxM+oVCIkydPIiEhAS+88AKCg4M71RT54sWL+P7773Hw4MEnxm/8+OOP2HtxLzAGndYIA7oBPGw9sGnMph5rRBsqFb42SJIEt4qLpKwk3Cm9g2x+Nmj//0P+/4+3nTdGDxqNGUNm4P3Q97H3670qc1OKxWKcOXMGR44cwahRoxAaGtrrfneSJFFRUaHkHi0pKcGwYcMUO0J/f/92o1opeofi4mJER0fj1q1bWLZsGRYvXqw37jdtQSwWY+vWrbCwsMCnn36qVw9/JEli2bJlCAsLw/jx4zVtTqdpT/jEYjFOnz6No0ePdnntPHv2LGJiYnDo0KEnXkOSJJYvXw4Wi4Xx48d3WiPm+swFYwBDpd4ztQjfo8gIGfgiPqRyKYwMjGBnZqdUVy0hIQFcLhdffPGFSucVCoU4deoUjh8/jhdeeAEhISEarQjR3NyM9PR0hXs0PT0d9vb2Su7RwYMHU0EzvUBZWRliYmJw8+ZNLFmyBIGBgbCw6LgYA0XXEQqFeOuttzBgwAB88MEHehcJ23aud+LECZ36u31U+HrqLUtISEBiYiLCw8MxaNCT++d19Fk9TSNUTa8I39MQCoWYPXs2YmNj1SJMzc3NSExMRGJiYqf91L0BQRDIy8tTSqVobGyEv7+/wj06YsQImJmZadpUvaGyshIxMTG4ceMGFi9ejKVLl+pFVKE2IhAIsGHDBnh6euLdd9/VKWHoLOvWrcOMGTMwY8YMTZvSJdqETyKRICkpCXFxcfD19QWLxepyfERsbCySk5MRHh7eYcDLunXrEBAQgJkzZ/bU/B6jFcIHAIcOHUJDQwN27NihtjmampqQkJCAU6dOdSoySRPU1tYqUii4XC6ys7Ph4eGh1JVC22zWBR6uLLFgwQKsWLFCKY2GQrU0NDTgjTfegL+/P7Zu3aqXopeZmYmtW7ciKSlJ59y3zz33HHbu3ImYmBh4eXmBxWJ1+aiJJElERETg+vXrCA8PV+qs8yiZmZnYsmULLly4oBWfldYIH5/Px8KFC3HmzBm1J4s3NDTg2LFjOHv2LKZOnYrVq1drbaUFiUSCzMxMhRimpqbCyMhIyT3q7e1N5Za1Q21tLeLi4nD58mXMmTMHK1eupM5V1Qyfz8e6deswbtw4vPnmm3ob2bxjxw74+/tj6dKlmjal08jlcly+fBkrV67EsmXLwGaz4e/v3+VxSJLEd999h7/++gvff//9U9fsHTt2wM/PD8uWLeuu6SpFa4QPaI32sra2xrp163plPj6fj6NHj+LChQuYMWMGVq1a9cTqA9oESZIoLS1Vco+Wl5fD19dX4R5lMBh9fjdTV1eHI0eO4MKFCx1WlqBQLdXV1QgLC8OUKVMQGhqqt6JXWlqKVatWITk5WSeCoR6tevXbb78hIyOj22N9/fXXSE9Px8GDB5+61pSWliIoKAgXL17Ums9Kq4RPUx+Qru8KmpqaFIW4uVwu0tPT0b9/fzCZTMXO0N3dXW8XoYd5eDf/tMoSFKqloqICYWFhmDNnDlavXq1pc9TK7t27YWNj02sP6d2FIAilOsdhYWEYNWpUtyu3EASBzz77DAUFBfjuu+861emmtzc0nUGrhA/Q7Jb40XOg5cuX62QNQblcjtzcXCX3qFAoVOwGmUwmhg8frld5ak1NTTh+/DhOnTqFyZMna+X5rT5TWlqKsLAwLFmyRKdcf92hN49lugtBEPjll1/A4XBgbm7+WGeb7gifXC7Hhx9+CB6Ph2+//bZTmxNt/ay0Tvi04RC0srIShw8fxv/+9z+9ifzj8XhKlWbaKqM/7B7VxZ1RW8TuiRMnMGHCBK2J2O1LFBYWYt26dVi7di0WLFigaXPUzqFDh9DY2KhIyNcmSJLEb7/9Bg6HAwMDA7DZbIwbN+4xb09XhU8qlWLnzp0QiUT46quvOv3QHB4ejvr6erUGLXYHrRM+QHvCXh/O9QoMDMSSJUv0JterpaVFUYi7bVdoZmam5B4dOnSo1uZdPZqj2dnKEhSqJTc3F2+88QbeeOMNjf+99gZCoRCzZs1CfHx8u/lqmoAkSdy6dQscDgdSqRRsNhsTJkxo93ijK8InkUiwfft20Gi0LlXdUXeaWk/QSuHTtqTQvlDdgyRJFBcXK7lHq6qqMGLECKVKM5re+T5aWSIkJAQeHh4atamvkpmZiY0bN2Lr1q147bXXNG1Or5CQkIC0tDTs3r1b06YAaP27vXPnDjgcDpqbm8FisTBp0qSnrpudFT6xWIwtW7bAysoKn376aZeix9VVmEQVaKXwPVzaZsKECZo2R0FBQQGioqL6TD3HxsZGJfdoRkYGnJ2dldyjrq6uvRI001ZZIj4+HgwGo1frsFI8DpfLxZYtW/Duu+9i0qRJmjanV5BKpZgzZw727t0LX19fTZuDv//+GxwOB7W1tWCxWJgyZUqnNwqdET6hUIhNmzbBycmpy1V3ZDIZ5syZg6+++kotHXN6ilYKH9Ba+PXUqVOIjo7WtCmPkZubi8jISHC5XAQFBWHBggV6VXS3PWQyGbKzsxXu0ZSUFEilUqXk+uHDh6v0s9BE5w2Kjvnnn3/w9ttv4+OPP8a4ceM0bU6vcenSJVy5cgWHDh3SqB2pqangcDioqKhAaGgopk6d2uUjiacJX1NTEzZs2AAvLy/s2LGjy563y5cv49KlSwgPD+/Sdb2F1gqfLrT6yMrKQkREBB48eIDVq1djzpw5fUIAH6aqqkrJPVpQUIChQ4cqxJDJZHYrf+7hXotDhgzpVmUJCtXz119/4b333sPu3bvx/PPPa9qcXoMgCAQGBmLLli0YM2aMRmxIT08Hh8NBcXExgoODERAQ0O3CFR0JX0NDA9avXw8mk4mtW7d22aPT9llt3rwZY8eO7ZZ96kZrhQ8ATp8+jVu3buGbb77RtCkd8nCX7rVr12LWrFl9tpKKSCRCRkaGwj2alpYGS0tLJfeol5dXu0+QbZUloqOj4erqChaLpbUPPn2Nmzdv4pNPPsFXX32FkSNHatqcXqUtUvLYsWO9ng+bmZmJiIgI5OTkKNaXnka8tyd8qqi68/vvv+PQoUM4fvy41uYOa7XwicVizJ49GxEREToRwMDlchEREYGSkhKEhIQgICBAa6Mie4u27vUPR4/W1NTAz89P4R719/eHmZmZorKEo6Mj2Gw2nn32WU2bT/H//O9//8OXX36Jb7/9FiNGjNC0Ob1OcHAwFi9e3KtBPNnZ2YiMjMT9+/exevVqzJ07V2UepScJH4/HQ1hYGKZOnYqQkJBui1ZISAgWLlyIqVOnqsJU9UBqOVFRUeRHH32kaTO6xN9//02GhISQc+fOJS9fvkzK5XJNm6RV1NXVkb/++it54MABcu3ateSIESPIQYMGkc899xy5b98+srS0lCQIQtNmUvw/V65cIV977TUyKytL06ZohNTUVHLWrFmkTCbrlfny8vLIt99+m3zttdfI48ePk2KxWOVzPPfcc0r/X15eTs6ZM4eMi4vr0bi9/Vl1F63e8QGtkYVz587FiRMndCrBmiRJ3Lt3D+Hh4WhsbERoaCgmT56sFekZ2kBbZYmIiAgYGxtj+vTprQ2M/39XSBCEUk7hsGHD+tz5qTZw4cIFcDgcfP/99/D09NS0ORphy5YtGDt2LBYtWqTWeYqKihAZGYm7d+9i+fLlWLRokdpakj284yspKcG6deuwbNkyBAYG9mjcrVu3YvTo0Vi8eLEqzFQbWi98ALB3714YGhpi48aNmjaly5Akidu3byM8PBxisRgsFgsvv/xynxVA8qHKEnQ6HWw2Gy+++KKSW4X8/+71D7tHi4qK4OPjoxBCBoOhVSWQ9JFTp04hPj4e4eHhfbY4QEFBAVgsFpKTk9WWulRSUoLo6Gj88ccfWLp0KQIDA9WeJ9wmfAUFBVi/fj2Cg4Mxf/78Ho1ZWFiI0NBQtX5WqkInhK+yshJLly7FhQsXNJ5A3V1IksQff/wBDocDgiDAZrMxfvx4rT38VTXkI5UlWCwWJk6c2On3LxQKkZ6erhDCtLQ09OvXTyl61MPDo88+UKiao0eP4vTp0+BwOH26BNzHH38MFxcXBAcHq3zs8vJyxMTE4JdffsHrr7+OpUuXdqrosyoYNWoUEhMT8eabb+LNN99USSPdTz75BE5OTggJCVGBhepFJ4QPAHbt2gUPDw+dr/pOkiR+/fVXREREwMjICGw2Gy+88ILeCiBJkrh79y44HA4EAkGnK0s8DYIgUFBQoIge5XK5qKurg7+/v2JX6Ofnp3cVdtQNSZKIiYnBlStXwOFwdOp4QdXweDwEBgYiKSlJpW2+qqqqcPjwYfz0009YtGgRli1b1uttxPz8/ODi4oJt27ZhypQpPR6vuroar7/+Os6fP68Thf11Rvhyc3Oxfv16XLx4US/OegiCwI0bNxAREQErKyuw2Ww8//zzeiWA//zzDzgcDmpqarpcWaI78Pl8JfdoVlYW3N3dlZr2Ojk56dVnrEpIksShQ4fw66+/Ijw8vM/3L9y/fz9kMhm2bNmikvGqq6sRGxuLq1evYt68eVixYgVsbW1VMnZX4HK5eOmll3Dx4kVMnDhRJWN+9913kEgk2Lp1q0rGUzc6I3wAsHHjRkycOLHHvmhtgiAIXLt2DZGRkXBwcNCLMH4ul4vw8HBUVFQgJCQE06ZN00hah0QiwYMHD5Sa9hoYGCi5R729vTXWBUSbIEkS3377Le7du4dDhw5pZEHWJpqamjBnzhwkJCT0uL0Vn89HXFwcLl26hFmzZiEoKEhj59N///03tm/fjtLSUjx48EAlYwoEAsyePRvHjx+Hs7OzSsZUNzolfP/88w8++eQTnD17Vu/OcuRyOa5evYrIyEgMHDgQbDZb5xK379+/Dw6Hg8LCQgQHB2PGjBlalchPkiTKy8uV3KOlpaXw9fVV6lWoC64aVUIQBL788ks8ePAABw4c6HW3mzYSFxeH/Px8fPzxx90eo76+HkeOHEFSUhKmT5+O1atXw8HBQYVWdo1bt25h165d+PzzzxEWFtatRrRPIj4+Hrm5ufjkk09UMl5voFPCR5Ik1qxZgxUrVuCVV17RtDlqQSaTKSqXDB48GGw2W+sThh88eICIiAhkZWUhODhYJZUleguBQKAUNJOeng4HB4fHutfr24NWGwRB4JNPPkFJSQn279+vN223eoJEIsGsWbPw/fffw8vLq8vXNzY24tixYzhz5gymTJmCtWvXavystK3qztdffw0mk9ntDuyPIpFIMHv2bBw4cABDhw5VgaW9g04JHwD8/PPPiI2NRXx8vF6f1UilUiQnJyMmJgY+Pj5gsVgYNmyYps1SIicnBxEREWqpLKEpCIJAbm6ukntUIBAogmbauterK7+qN5HJZNi1axfq6+uxd+9evXhPquD8+fP45ZdfsH///i5dJxAIkJCQgJMnT2LSpElYs2aNVkTEXr9+HXv27MG+ffsU9W5VJXxJSUm4ceMGvvvuux6P1ZvonPARBIFFixZhx44dGDVqlKbNUTsSiQTnz59HbGws/P39ERoaqvEnq/z8fERGRuKff/7BqlWrsGDBApiYmGjUJnVSU1OjEEIul4ucnBx4enoq3KMjR47U+BN9V5FIJNi5cyckEgn27Nmj1/evKxAEgYULF+K9997r9Fm7UCjEiRMnkJCQgJdeegnBwcFa06T2ypUr2L9/Pw4cOKDU1UQVwtf2We3cuRPPPfdcT03tVXRO+IDWahL/+9//dO4poye0tLTg7NmziIuLw7PPPovQ0NBer6RRVFSEqKgo3LlzR+2VJbQZiUSCjIwMpV2hiYmJUvTo0KFDtep882FaWlqwbds2mJiY4LPPPtP5XboquXHjBo4cOYLY2NinepREIhFOnz6NY8eOYfTo0QgNDdWqRP/z588jKioKBw8efGytUIXw3bhxA/Hx8YiLi9M575tOCp9EIsGcOXOwf//+Ptebre2P7ejRoxgzZkyv/LGVlpYiOjoav//+e69VltAlSJJESUmJkhBWVlbC19dX4R719/fXiqARkUiEzZs3o1+/fvj444+1Vpw1AUmSCAoKwurVqztsrqsND6FP49SpUzhy5AgOHTr0xPWhp8JHkiRWrVqFoKAgnYy30EnhA4AjR44gOzsbn376qaZN0Qi94V6pqKhATEwMfv75516vLKHrNDY2Ij09XeEevX//PpycnJTco73Vvb6N5uZmbNy4Ea6urnj//ff1NmCnu/z999/47LPPcObMmSd+Nm3HDnFxcfDz89OKY4cnceTIEZw9exbh4eHtnjH2VPj++ecffPrpp+1+VtqOzgpfW+7IsWPHtOIAWVM8eqC+du3aHufS8Hg8xMTE4KeffsLChQuxfPlyrdit6DJyuRw5OTlKu0KRSKTkHh0+fLjaztoaGxvx5ptvwtfXF2+//bZOLlbqZsOGDXjllVcwd+5cpX/XhUAzoHUXFh0djatXryI8PLzDc+eeCt+GDRswadIkzJs3r9tjaBKdFT6gtVpA23lFX0cVIdQ1NTWIjY3FDz/8gLlz52LlypV9PpFZnfB4PCUhzM/Px5AhQ5RSKRwdHXs8T11dHdavX49Ro0bhrbfe0rnzmN4gJycHGzZswIULFxRnno+mFrFYLPj5+WnY0idDkiS+//573Lx5s1NVd3oifDk5OXjzzTeRnJyss+fDOi18NTU1WLx4Mc6dO0ct0P9Pd5Jm+Xw+4uPjcfHiRcycOROrVq2iOh9oALFYrOhe3yaIlpaWSu7RIUOGdKkKTk1NDdatW4eXX34ZYWFhlOi1w/vvv4+hQ4di5cqVimISUVFRcHFxAYvFApPJ1LSJ7UKSJL755hv8888/+P777zu1FvZE+Hbt2gVPT0+sWrWqW9drAzotfADw6aefon///ggNDdW0KVpFZ8okPSqSq1atUskOg0I1kCSJoqIipV0hj8eDn5+fwj3q7+/f7rlrVVUVwsLCMGPGDKxdu7aXrdcdysvLsXz5ciQlJeHPP/9EZGQk7O3tERYWpvXlAwmCwBdffIHs7GwcOHCg091ruit8FRUVWLZsmU53ygH0QPiKiooQHByM5OTkPhla/zSeVBiXTqcruUXXrFmDAQMGaNpUik7Q0NCAtLQ0hRBmZmbCxcVFyT06aNAgVFRUgM1mY/HixVi+fLmmzdZqvvrqKxQWFqK6uhoWFhYICwvTiYLxcrkcH3/8McrLy7F///4uRVp3V/j27t0LIyMjbNiwocvXahM6L3wAsG3bNowaNQqvv/66pk3RWqqqqhAeHo4TJ04AABYuXIh169b16cAgfUAmkyE7O1vJPdrU1ISysjJMnz4doaGh8PX11dmzGHVCkiQuX76MtWvXYuLEidi0aZPOtAiTyWR4//330dDQ0K2qO90RvoaGBsybNw8nTpzQuYINj6IXwpeeno4dO3YgKSlJI10AtJ2HUx+YTCZoNBr+/fdfKkVBD8nPz0dwcDAmTJgACwsLpKamorCwEN7e3kpdKfryGe7DTaGzs7Ph7++P6OhonRA8oDWtYseOHZDL5dizZ0+3Hmq6I3xRUVGoqKjArl27ujyftqEX2at+fn5wdnbGTz/9hGnTpmnaHK3h0coSMTExcHd3BwCUlJQgOjoac+fOpZLS9YTs7Gy8+eab2LZtG6ZPn674d6FQqAiaOX/+PD7++GNYW1sruUeHDBmi9ykOJEnir7/+AofDgVgsxurVq/H1119j165dOiN6bVHspqam+OKLL3qtGLxYLMbp06cRGRnZK/OpG73Y8QHAH3/8ge+//x7Hjx/XmS+xumirLBEfH49nnnmmw8oSRUVFiIyMxN27d/t0GTJd5/79+3jrrbfwzjvvPLWSBkEQKCwsVHKP8vn8x4Jm9OlB6O7du+BwOGhoaEBoaCgmT56MM2fO4O7du/jqq680bV6nEAqF2Lx5MxwcHPDRRx/1yLvV1R3fqVOncPv2bezdu7fbc2oTeiN8JEkiMDBQ4afvi0gkEiQlJSE2NhYjRowAi8XqdGWJ/Px8REREICUlBUFBQXpfeFqfSElJwbZt27Br1y6MHz++W2PU1dUpBc08ePAAbm5uSu5RZ2dnnXuo/Pfff8HhcMDj8RRNkel0OuRyOebNm4fPPvsM/v7+mjbzqQgEAmzcuBHu7u547733erw774rwtX1Wn376qc71CG0PvRE+oLUSeXJyMjgcjqZN6VWkUikuXryImJgYeHt7KwIaukN2djYiIyP1qtWQPnPnzh28++67+OyzzzBmzBiVjSuVSpGVlaUQwtTUVABQco8OGzZMa/sucrlccDgclJaWIiQkBAEBAUo7pB9//BFnz57VCdddY2Mj3njjDQwfPlxlVXe6InzXrl3D6dOnERUV1eN5tQW9Ej6ZTIa5c+diz549ir5T+oxMJsOVK1cQHR0Nd3d3lVaWyMzMREREBHJycrB27Vqdai7bV/jjjz/wwQcfYM+ePWrPNyNJEhUVFUru0eLiYgwbNkyxK2QwGOjXr59a7XgaGRkZ4HA4yM/PV3xvHy3ETZIkli1bhvXr1+PFF1/UkKWdo63qzvPPP49NmzapbMfdWeFr+6zCwsK67U3QRvRK+AAgMTERKSkp+PLLLzVtitp4uLKEs7MzWCwWRo4cqZa50tPTweFwUFxcjODgYAQEBFAV/bWAn3/+GZ9//jn27t2rMfdTc3Mz7t+/j5SUFHC5XKSlpcHe3l7JPTp48OBeCZrJzs4Gh8PBgwcPsHr1asyZM6ddT8WtW7ewb98+nDhxQqtdtzU1NQgLC8Mrr7wCNputUls7K3x//fUXvvnmG5w4cUKvgp/0TviEQiFmz56Nw4cPa1VvLFVAEAR++uknREZGws7ODmw2u9caQKakpCAiIgIVFRWKsxIqdUQzXLt2DV9//TW+++47rSqWTBAE8vPzFa5RLpeLhoYGRfd6BoOBESNGqDRoJi8vDxEREUhNTVU0RX6aaz4sLAyzZs1CQECAyuxQNZWVlQo716xZo/LxOyt869atQ0BAAGbOnKlyGzSJ3gkfAHA4HPD5fLz77ruaNkUlEASBn3/+GRERERqvLPH3338jPDwcdXV1CA0NxZQpU/TqSVDbuXjxIr7//nscPHgQXl5emjbnqdTW1oLL5Srco9nZ2Rg8eLDSrnDAgAFd/i4XFhYiMjIS9+7dw8qVK7Fw4UKYmpo+9bqMjAxs27YNFy5c0FrPRVlZGcLCwvD6669j2bJlapmjM8KXmZmJrVu3IikpSe+OOfRS+Orq6rBgwQKcPn36qVXKtRmSJPHrr78iIiICRkZGYLPZWlFZgiRJ3LlzB+Hh4RAKhWCxWJg0aRIlgGrm7NmziImJwaFDhzB48GBNm9MtJBIJHjx4oLQrNDQ0VBJCb2/vdkWpuLgY0dHRuHXrFpYtW4bFixd3aQe5fft2MJlMLF26VFVvSaUUFRUhLCwMa9aswcKFC9U2T2eE75133gGDwdDaz6on6KXwAcCXX34JS0tLrF+/XtOmdJmHK0sQBAE2m43x48drXPAehSRJ3Lp1CxwOB1KpFCwWCxMnTtQ6O/WBhIQEJCYmIjw8XOUNhzUJSZIoKytTEsKysjJF9/q2zhQCgQAxMTH49ddfsWTJEixZsgQWFhZdmqukpASrV69GcnKyVuYo5uXl4Y033kBYWBhmz56t1rmeJnwlJSVYtWoVLl68qJWfVU/RW+ErKyvDypUrkZyc3OU/EE1BkiRu374NDocDkUgEFouFl19+Wet3UiRJ4rfffgOHwwGdTgebzcaLL75ICaCKOHz4MC5evIjw8HA4OTlp2hy109TUhPT0dHC5XNy6dQu//PILhEIhxowZg2XLlmHs2LFwd3fv8vfr888/V5yNaxsPHjzAhg0bsGXLFkydOlXt8z1N+Hbv3g0bGxusW7dO7bZoAr0VPgB49913MXz4cJ2oTn/v3j1wOBzU19crKktou+A9CkEQ+OWXX8DhcGBubg42m40xY8ZQAthNSJJEREQErl+/jvDw8D7VMorH4yE2NhY//vgj5s2bh3HjxikCZ7hcLgQCgZJ7dPjw4R2e8dXW1mLRokU4c+aM1tUpTU9Px+bNmztVdUdVdCR8fD4fCxYswNmzZ7Xus1IVei18WVlZeOutt3DhwgWtPZxNSUlBeHj4Y5UldBmCIHD9+nVERESgX79+YLPZGDVqlKbN0ilIksR3332Hv/76C99//73eLkCPUltbi7i4OFy+fBlz5szBihUrnvjeq6urFQEzXC4Xubm58PT0VLhHmUymUgeBQ4cOoampCdu3b+/Nt/NU/vnnH2zfvh0ffPABXnrppV6btyPhO3ToEBoaGrBjx45es6e30WvhA4D169dj6tSpaveZd5W0tDRwOByUlJQgODgYM2bM0Lv0AIIgFPmG/fv3R1hYmNryDfUJgiDw9ddfIz09HQcPHoS1tbWmTVI7dXV1OHLkCC5cuIAZM2Zg1apVXQpMa2lpQUZGhlLTXjMzM0WFmfDwcJw8eVKrUpzaqu58/vnnGD16dK/O3Z7wCYVCzJo1C/Hx8Xp1lvwoei98d+7cwVdffYWTJ09qxU4qIyMDERERyMvLw9q1azFz5kyt3Y2qCrlcjsuXLyM6Ohqurq5gs9k6UR9RExAEgc8++wwFBQX47rvv9L5lVENDA44dO4azZ89i6tSpWL16tUp6vZEkiZKSEqSmpiI+Ph7379+Ho6Mjhg8frnCP+vn5aeyh4vfff8dHH32EPXv24Jlnnun1+dsTvoSEBKSlpWH37t29blNvovfCR5IkVqxYgdDQUEyYMEHx7zJCBr6ID6lcCiMDI9iZ2cGQrr68nq5UltBXHq4p6uXlBRaL1SdKy3UWuVyODz/8EDweD99++61eRtO10dTUhOPHj+PUqVOYPHky1qxZo5bAHalUijlz5uDbb7+Fs7OzohA3l8tFRkYGnJyclNyjrq6uaj+TvnHjBnbv3o1vvvmm1x8A29a9yVMn4/qP15XWvbbPau/evd2u9asr6L3wAcBPP/2EhMQEbPx8Iy5kXcBfpX8hl58LGv77gpMg4WXnhbGDxmKOzxwwBzBV8gfQncoS+s7DXSR8fX3BZrPh7e2tabM0ilQqxc6dOyESifDVV191KhlbF2lubkZiYiISExMxceJErF27FgMHDlTbfBcvXsTVq1fx/fffP/Y7mUyGnJwcJfdoS0uLUtCMr6+vSruUXL16Fd98802vVd0hSRKpVamPrXvFxcVwc3NTWvf6VfVD5i+ZCD8Urna7NI3eCx9JkriUfQlrItfAzNkMhkaGMDU0hamhKei0/1yfBElALBNDLBPDgGYAj34e2DhmIwKGBnRLAB+uLLFixQosWrRIbxez7tLS0oJz584hLi4OTCYTLBYLQ4YM0bRZvY5EIsH27dtBo9HwxRdf6OWDkVAoxKlTp3D8+HG88MILCA4OVvt5G0EQeP3117Ft27ZOn6FVVVUpBc3k5+fDy8tLqSuFg4NDt+xJTk5GeHg4Dh48qPbvOUmSuJJzBftv70dBXQHkpFxp3cvMzISvr6/SulddVY3hLsOx67Vd3V73dAW9Fj5eMw/br2/HzaKbEDeLIRVK4eb69D82kiQhlAohkUswYfAEfDn5S/S36Ny5Q0lJCaKiorpdWaIvIhKJcObMGRw9ehSjRo1CaGiozlYm6SpisRhbtmyBlZUVPv30U60to9Vd2jp3t93bkJAQeHh49MrcN2/eRGRkJI4ePdrtRVwkEim617eVXrO0tFRyj3p5eT01fuD06dOIjY1FeHg43N3du2VLZ3l43TOmG8PcyPyx998mfG0IBALwqnkYMHBAt9Y9XUNvhS+lMgVBSUFoljTDxsQGAJCTmwN3N/dOuy5IkkRDSwMsjS0RPzceTCdmu68tLy9HdHR0jypL9HWEQiFOnjyJ48ePY9y4cQgJCYGrq6umzVIbQqEQmzZtgpOTEz744AO9iuqVSCQ4e/asYjcfGhra67VF165di8DAQEyZMkVlYxIEgaKiIiX3aHV1Nfz8/JSCZh4OSjp+/DhOnjyJ8PBwtbp1gcfXvfYE/1HhKyoqQr9+/WBtbd2ldU9X0UvhS6lMwdKzS0GQBCyN//sC1tTUQCKVwMXZpUvjCSQC0Gl0JC5IfOxLUFlZicOHD+P69etYvHgxli5d2ifCz9WJQCBAYmIiTpw4gYkTJyI4OBguLl27Z9pOU1MTNmzYAC8vL+zYsUMrIo5VgUQiwYULFxAbG4thw4aBxWLBx8en1+1ITU3Frl27cO7cObU/UNTX1ysFzWRmZmLgwIFgMpmoqqrCgwcPEBcXp/aqO+2te0/iYeETiUQoKyt77MGko3VP19E74eM18zDl6BS0yFoeu/lyuRx5eXnw9PTssktJIBHA1NAU11ZcQ3+L/uDxeIiLi8PVq1cxf/58rFixAjY2Nqp8K32exsZGJCQkqD3yr7dpaGjA+vXrwWQysXXrVr04S5HJZIqIXU9PT7DZbI1G7G7evBnjxo1Ta6Hn9mjrXr93717cunULAwcOhIGBgZJ7dNiwYSo9y+1o3XsSDwtfaWkpLCwsnthE+NF1T1/QK+EjSRJrktfgt6LfYGtq+8TXFP1ZBGm5FIZCQ7RUtYCQELD2s8bAOU93QdSL6zF6wGg8V/ocLl++jNmzZ2PlypV9pqqGpmhoaMDRo0dx7tw5TJs2DatWrVJJrpcm4PP5CAsLw4svvog333xT50Xv4RzNQYMGgc1ma6wxbhv5+flgs9m4ePGiSiMyOwtJkti3bx/u3r2LgwcPol+/fqisrFRyjxYVFcHb21spaKa760hn1r1HyczMhIvMBaUXSiGRSDB43mD0e+Zx4QNa173x7uNxePZhnf++tqFXwnc5+zI2XN0AWxPbdm9QXlQeGksaYWZlBiNrI0hqJJ0SPrlcjpqaGtQ012CZ7TJ8EfxFt6O7KLoHn8/HkSNHkJycjJkzZyIoKEin2k7xeDyEhYVh6tSpCAkJ0elF5OGqPI6OjmCz2Xj22Wc1bRYA4KOPPsKgQYOwdu3aXp+bIAh89dVXuH//fodVd4RCIe7fv68UNGNra6skhJ6enp1ygXdm3XuUjHsZMPjVABKxBJABrnNcYTvS9omvJUkS9eJ6HJh+AAHe2tu8tyvojfCRJImpx6aipKEEFsbtB5U0FzaDL+LD1MEU5kJzFB8r7lD45HI5avm1qK+rh7W1NcxszOBh54Efl/+o0wuXLlNTU4O4uDhcuXIFc+bMwcqVK5/optEmKioqwGazMX/+fAQFBWnanG7TVoc1MjIS1tbWCAsLw6hRo7Tmb4HH4yEwMBBJSUm9ftZOEAQ+/fRTFBYWdrnqDkEQKCgoUAhhamoq6urq4O/vr3CP+vn5PRYh3tl179FruIe4MCfN0eLQAnoeHS4zXNoVPgBoljTD1cZVb9Y9vYmdTq1KRUFdAaxNOv6yWwy2gGGLIYqKi2Bu1H6aAUEQqK2tRV1dHaysrODh4QEjIyOQJImC+gJwq7h6d+CrKzg4OGDr1q1YuXIlDh8+jAULFmDBggVYsWKFVgYWlZSUICwsDMuXL0dgYKCmzekWbZ03IiIiYGpqii1btmDs2LFatwgmJCRg5syZvf49kMvl+OCDD1BTU4ODBw92OYWJTqdjyJAhGDJkCObPnw+g1cPRFjQTERGBrKwsuLm5Ke0Kq2hVnVr3Hqbubh2IKgJm881AL6NDAslTrzE3MterdU9vhO9C1gXISXmn/hBNTExgZmoGQYPgsd8RBAE+nw8+n68keG3QaDTICTmSspL04gugy/Tv3x/vvPMOgoKCcPjwYcybN08RWWtlZaVp8wAABQUFWL9+PYKDgxULmi7xaK/FN998U2t7LTY2NiI5ORmJiYm9Om9b1R2xWIz9+/er7FzRzs4OEydOxMSJEwG0RsxmZWUhNTUVN27cwDfffIN8t3zUDKyB3EwOMzMzmJqadnhvWmpawPuZB7oPHUJzIazNrTslfPq27umN8P1V+hdMDTtfGcXe3h4lxSWK/ycIAnV1daitrYWlpSUGDx7cbtSVqaEp7pTe6bHNFKrB2dkZO3fuxKpVqxAdHY158+ZhyZIlCAwM1GguZXZ2Nt58801s2LABM2bM0Jgd3YEkSdy6dQscDgdSqRQsFgsTJ07USsFr4+zZsxg/fjwGDBjQa3NKJBK8/fbbMDAwwNdff63WqjvGxsbw9/dX1PckSRKvHH4FkhoJJC0S1NfXQyqVwtTUFGZmZjA3N4eZmZkinYMkSJQnl7fGNoyQwNLSskupHvq07umF8MkIGXL5ubAy7vxTvrm5OQzoBpDKpRCLxMjNy4WFuQXcB7vDxLjjJzZTQ1Nk87MhI2RqLWxN0TUGDhyIDz74AMXFxYiKisLcuXM1Vj0nIyMDmzZtwrZt21SaQK1uSJLE3bt3weFw0NTUBBaLhVdeeUXr8wwlEglOnDiBQ4cO9dqcIpEIW7ZsgY2NDT755JNer7ojJ+UoFZbCwdZBUX6RIAiIRCIIRULw+XyIRCIYGhrCzNwM0lQpRBUiuK90R3ZNNuzt7dGY29jp+fRp3dNt6/8fvogPGmhKtTc7g62tLUpkJTCUGsLDzaPTLgo6jQ4aaOCL+HqV26IvuLm54ZNPPkF+fr5CAFeuXImFCxf2Sr1ULpeLLVu24L333lO4qXSBf/75BxwOBzU1NQgNDcVrr72m9YLXxqVLl+Dr69trtV6FQiE2btwIFxcXfPDBBxr5nJ607tHpdFhYWCh5OlpaWlCXX4f6v+pB86YhuyYbdDq9yy5ZfVr39CKqs6yxDJPiJ3XpgBcAmouakR+XD2IQAeNxXXNRyA3l8L7lDWOx/hUU1jdaWlpQXV0NkUgEe3t79OvXT20uu+bmZpSVlcHFxUVneukJhUJUV1dDKpXC0dER1tbWWu3SfBSSJJGfnw9nZ+de2dnL5XKUlJTAxMQETk5OGvusJKYSZL+QDQPZ4+5KkiRBEAQIgoBcJgdxjQBoAF4BDIwMYG1tDU9PT1TfrEbNbzVwnuHcYVRnG00tTbgRdAMDrdVbek3d6MWOz8ig+41cDQ0NYe1gjYG+XbuRjS2NuP7hdZ1/8ulLZGVlISIiAg8ePMCaNWswe/ZslZ7J3Lp1C++//z6OHDmC559/XmXjqov79++Dw+GgsLAQu3fvxowZM3SySPb//vc/HD9+HDExMWoXofr6eqxfvx7Lli3Dli1bNPqAwGvm4aXDL8HaxBotLS2tLk6hEEKREHK5HFZmVjAxMYG4SYxaYS0MDAxgeM0QNNDQghZkIlMxVsXlClRcroDdaDsMmNL+GSkJskfrrbage9/yJ2BnZgcSJAiS6LK7szsQJAESJOzMqIotuoSPjw+++eYb3L9/HxEREYiPj8fatWsxc+bMHi/4N2/exCeffIK9e/eCydTuqLcHDx4owuPXrl2L2bNnK0Uu6xIkSSI+Ph5r1qxRuwi1Vd0ZP3481q9frzHREwqFSE9Pxz8p/4DH46FcWA4jQyNFQIu9vT0MDQ3B5/Nb07HMreD4vCMM6I/vDMWVYogrxTBzNYOJvQnMBpq1O68+rXt6IXyGdEN42XmhqL7j3DxVIZaJ4W3nrfMHvH2VESNG4LvvvgOXywWHw8Hhw4cREhKCgICAbhU0vn79Ovbs2YP9+/drdUf5nJwcREREID09HatXr8aXX36p873//v77bwiFQkyYMEGt8/B4PLDZbEyfPh3BwcG9JnokSaKiokIpsb2kpAQ+Pj5gMBjwcfRBPephZdoa2EcQBGr5tajjK+cfY9CTx6++WQ1xpRi2DNunujr1ad3T/Xfw/4wdNBZZNVlPFb6mrCY0ZTcBAGQCGQBAVCZC+cVyAICBmQEGTO44HFosE2P0oM41tqTQXhgMBg4dOqQI6oiNjUVISAimTp3a6WCFK1euYP/+/Th48KDWdpHPz89HZGQk/vnnH6xatQqfffaZRmpYqoP4+HisXLlSrcEl5eXlCAsLw4IFC7By5Uq1zQP8V+Cay+UiJSUFXC4XBEFg5MiRYDKZCAgIgI+Pj+KBpe7XOsSnxCvlH1taWmKwx2AYG6n2oUaf1j29CG4BWltyLDq1CNYmHR/Mtx3mtoeRjRG83mi/bxhJkmiUNOLMojN6kchJ0cqjYfyhoaF49dVXO1xQz58/j6ioKBw8eBCenp69aG3nKCoqQlRUFG7fvo0VK1Zg0aJFMDNr35Wla2RnZ2Pjxo24cOGC2nauxcXFWLduHVasWIHXX39d5ePX1dUptTR68OABXF1dFWXKmEwmnJ2d213T/ir8C3OPz0VzfTMszS3h6OjYpc+is8Et+rbu6Y3wdadmXXdoljTDzcYNV5df1anIN4rOQZIk/vrrL4SHh6OlpQUsFguTJk167F6fPHkSR48exaFDh+Dm5qYha59MaWkpoqOj8fvvv2Pp0qUIDAzs9TzG3uC9996Dt7e32nZh+fn5eOONNxASEoJ58+b1eDyCIFBYWKjktqytrX2sHmdnii60tLS0NvqNj0P2mGwY9DNAPwv11avVt3VPb4QP6F6V8q6gj1XKKZ4MSZL4/fffweFwAAAsFgvjx48HjUbDkSNHcPbsWYSHh2tVg9yKigpER0fj559/RmBgIJYuXaozKRVdpby8HCtWrEBycrJaqvO0Vd3ZuHEjAgK697cuEolw//59hdsyLS0N1tbWSrU2hwwZ0iU3rUQiQVJSEmJjYzFixAiwWCxkk9nUutdF9Er4utOXqivUi+sxwX0CYmarP2yaQjsgSVJRnNnIyAguLi7Izc1FeHi41vQE5PF4iImJwU8//YSFCxdi+fLlWlmsW5Xs2bMHZmZmePPNN1U+dlvVnbfffhuTJ0/u9HUP99zjcrkoKCiAt7e3YjfHYDC63UZLKpUqGv16e3sjNDRU0UiWWve6jl4JH9Ca2/La0dcglok71Ym4s+hrJ2KKziGXy7FhwwYkJydj/Pjx2LRpE55//nmNLgQ1NTWIjY3FDz/8oKhOY2trqzF7eov6+nrMnz8fp06dUnlPzNTUVGzduhXvv/9+h5GiMpkM2dnZSm5LqVSq1GXd19e3x2ePMplM0eh38ODBYLFY8PPze+x11LrXNfRO+AAgtTIVS84uAUESKvkSCCQC0Gl0JC5I1IuDXYquQZIk9u7di3///RcHDhzA7du3ERUVBQcHB400YOXz+YiLi8OlS5cwc+ZMrFq1qtvdu3WRyMhIVFdXY+fOnSod9969e3jnnXfwySef4IUXXlD6XWNjo6JhbEpKSmsHcxcXJbfloEGDVPYgJJfLFY1+nZ2dwWazn5ofSq17nUcvhQ9o/RIEJQVBIBHAxsSmW19IkiRR31IPK2MrxM+N17ubT/F0CILAF198gezsbBw4cEDR7kgul+OHH35AVFQUBg4cCDabDQaDoVZb6uvrceTIESQlJWHatGlYvXo1HB0d1TqntiESiTB79mzExMSoNKjozz//xK5du/Dll1/i2WefRVFRkWInl5qaCh6PBz8/P6UgFHW0viIIAj/99BMiIyNhZ2cHNpuN5557rtPXU+te59Bb4QNat//br2/HzcKbMDYwhrmReae+CCRJQigVQkJIMMF9Ar6c/KVebfMpOodcLsfHH3+M8vJy7N+//4mRkTKZDJcuXUJ0dDQ8PT3BYrEwYsQIldrR2NiIY8eO4cyZM5gyZQrWrFnTq613tImTJ0/i77//xp49e1Q25k8//YT3338fAQEBqKurA5fLhbm5uZLb0svLq1vFDToLQRC4ceMGIiMjYWFhgbCwsG670ql17+notfABrTfzh5wfsO/2PhTUFUBOymFqaApTQ1Ol8mYESUAsE0MsE8OAbgAPWw9sGrMJ04dO15sDXYrOI5PJ8P7776OhoQF79+59av6bVCrFhQsXcPjwYfj4+IDNZsPHx6dHNggEAiQkJODkyZN4+eWXsXbtWq2KIu1tZDIZ5s2bh927dz/xnKuz8Hg8hdvyypUr+PvvvzFhwgRMnDgRTCYT/v7+vRa4RJIkfv31V0XwFJvNxgsvvNDjNYda9zpG74WvDZIkwa3iIikrCXdK7yCbnw3a//+Q///jbeeN0YNGY67PXDAGMPT6xlO0j0QiwY4dOyCXy7Fnz54uBShIJBKcO3cOcXFx8Pf3B4vFgpdX+wURnoRQKMSJEyeQkJCAF198EcHBwXB1de3q29A7fvjhB5w/fx6RkZGdvkYulyMnJ0fJbSkSicBkMkGSpOK8VtW79KdBkiT++OMPcDgcEAQBNputSJdR9TzUuvc4fUb4HkVGyMAX8SGVS2FkYAQ7Mzu9qEFH0TNaWlqwbds2mJqa4rPPPut28WaxWIyzZ88iPj4ezz33HEJCQp5a3UUkEuH06dM4duwYnn/+eYSGhsLd3b1b8+sbJEli6dKlePPNNzFu3Lh2X9fU1KRUCeX+/ftwcnICg8EAg8HAyJEj4erqivPnzyM6Ohrff/89PDw8evV93L59GxwOByKRCCwWCy+//HKv9fOj1r1W+qzwUVA8ilAoxObNm+Hg4ICPPvpIJWc6QqFQIWZjx45FSEjIY0EZiioccXF45plnwGKxtLIEmib5888/8d133yExMVGxIyFJEiUlJUrRlpWVlfD19VVEW/r7+z+W03jixAkcP34chw4d6tWddFtJvIaGBoSGhmLy5Mk60+hX36CEj4ICredpGzduhLu7O9577z2VL0jNzc04ceIEEhMTMX78eAQHB8PR0VGpCkdoaKjWFrrWNCwWCwEBAXB3d1dKEjc2NlZKKRg6dGiHLabi4+Nx7tw5cDgcODs794rt//77LzgcDng8HkJCQjBt2jRK8DQMJXwUfZ7Gxka88cYbGD58ON5++221LkpNTU04duwYDh06BIlEggkTJmDz5s2KKhwU/1FbW4vU1FT8+OOPSEhIgJubG4YMGaJwWzKZzE5Ht5IkiaioKPz444+9VnWHy+UiIiICJSUlCA4OxowZM9QaGUrRefqec5eC4iHq6uqwfv16PP/889i0aZNaD/ZlMhlu3LiBK1eu4IUXXkD//v3x559/4sKFC7C3t9eaEmiagCAI5ObmKrktBQIBGAwGsrKyEBYWhrfeeqtb3SVIksSBAwfw559/IioqSu3J/hkZGeBwOMjPz1c0OtbVRr/6CrXjo+iz1NTUICwsDK+88grYbLbaRO/RKhwsFgsjR44E0Cq8R48eRVJSEgICArBq1SqVl+HSRpqbm5GWlqZwW6anp8PBwUHJbenu7o7S0lKsXbsWycnJ3RI9giCwd+9epKam4vvvv4eNjY0a3k0r2dnZ4HA4ePDgAVavXo05c+bofKNffYUSPoo+SWVlJcLCwjBr1iysWbNGLXM8XIWjX79+CAsLa7cKR21tLeLj43Hp0iXMmjULQUFBelOGjCRJlJeXK9IJuFwuSktL4evrq3BbMhiMJ9YZ/fzzz2Fvbw8Wi9XleQmCwO7du5Gbm4vvvvtOLZVWACAvLw8RERFITU3FqlWrsGDBAkrwtBxK+Cj6HGVlZQgLC8Prr7+OZcuWqXx8giDw888/IyIiAubm5ggLC8Po0aM7taOsrq5GbGwsrl69innz5mHlypVq3aWoA4lEggcPHii5LQ0MDJQqoXh7ez/V/VdbW4tFixbh7Nmz6Neva73m5HI5PvroI1RWVmLfvn1q6UdYWFiIyMhI3Lt3T9Ho19TUVOXzUKgeSvgo+hRFRUUICwvDmjVrsHDhQpWOrcoqHJWVlTh8+DCuX7+ORYsWYdmyZVrbaojP5yty51JTU5GdnQ03Nzclt6WTk1OXP4eDBw9CKBTi7bff7tJ1MpkM7733HpqamrB3716Vi1FJSQmioqJw69YtLFu2DIsXL9bLRr/6DCV8FH2GvLw8rF+/HuvWrcPs2bNVNq46q3CUl5cjOjoav/76KwIDA7FkyRKNNpclCAIFBQVKbsu6ujoll6Wfn1+PhaC5uRmzZ8/G0aNHu1SmTSKR4J133gFJkvjyyy9V6nJ8+F4sWbIES5YsUUsTXAr1QwkfRZ/gwYMH2LBhA7Zs2YKpU6eqZMyHq3AIhUKw2Wy1VeFo22X8+eefWLp0KQIDA3tllyEUCpGenq5wW6alpcHW1lbJbenh4aHy93z06FE8ePAAn332WaevEYvF2LZtG8zMzHpUdedRHt59L168GEuXLtXa3TdF56CEj0LvSUtLw5YtW/DOO+/glVdeUcmY9+7dA4fDQV1dHVgsVq9V4Xj4XGn58uVYvHixylx5JEkqdRFPTU1FUVERfHx8lCqhqDvoRiKRYO7cufj22287XehbKBTirbfeQv/+/fHhhx+qJF+Ox+MhNjYWP/74I+bPn48VK1bo3HkrxZOhhI9Cr/nnn3/w9ttv48MPP8RLL73U4/HaqnBUVVUhNDRUY1U4Ho4kDAoKwoIFC2BiYtKlMaRSqaKLeJvbUi6XY+TIkQq35bBhw3o9QjE5ORnXrl3DwYMHO/V6gUCADRs2wMPDAzt37uzx/aitrUVcXBwuX76M2bNnY+XKlXoTYUvRCiV8FHrLnTt38O677+Lzzz/H6NGjezRWWloaOByO1lXhyM7ORkREBDIyMrB69WrMnTu3XaFqaGhQCByXy0VmZiYGDRqk5LZ0cXHRaHV+giCwePFibN++Hc8///xTX99WdcfPzw9bt27tkejV1dXhyJEjuHDhAmbMmIGgoKA+kVPZF6GEj0Iv+f333/HRRx9hz549eOaZZ7o9TkZGBiIiIpCbm4u1a9di1qxZWlmF41E7Z8yYgfLyciW3ZU1NDfz8/BRuSz8/P60Lzvj1118RHR2NI0eOPFWA+Xw+1q9fj7Fjx2LDhg3dFuyGhgYcO3YMZ8+exdSpU7F69eo+XUWnL0AJH4XecePGDezevRvffPMN/P39uzVGWxWOzMzMp+6ktAGRSISMjAxcvnwZZ86cQXl5OYYMGYIpU6YoXJdeXl5aXxx5zZo1WLp0KSZPntzh66qrqxEWFobJkyeDxWJ1S/Samppw/PhxnDp1Cq+++irWrl0LJyen7ppOoUNQtTop9IqrV6/im2++wYEDBzBs2LAuX//o2dnu3bu7fHbWG/B4PKSkpCjclvn5+Rg6dCiYTCb27dsHADh58iTS09Mxbtw4nRC9lJQU8Pn8pwYg9bTqTnNzMxITE5GYmIiJEyfi6NGjGDhwYHfNptBBqB0fhd6QnJyM8PBwHDx4EEOGDOnStY9W4Vi4cGG3akOqA5lMhpycHMX5XGpqKiQSieJcjslkwtfX94k70nv37iE8PBz19fW9Gn3aHd566y289NJLWLBgQbuvKS0txbp16xAYGIilS5d2aXyhUIhTp07h+PHjeOGFFxAcHPxYb0SKvgElfBR6wenTpxEbG4vw8PAudS1/OD9u2bJleP311zVehaOxsVGpEkpmZiacnZ0VQSgMBgOurq6ddu89mm/IYrEwadIkrRLA/Px8hIWFITk5ud0ddmFhIdatW9flqjtisRinT5/G0aNHMWrUKISEhPRq13UK7YMSPgqd5/jx4zh58iTCw8M77bLSlooobV3EH3ZbVlZWYsSIEQqh8/f3V0mBZZIk8eeff4LD4UAul4PFYmHChAkajeJs48MPP4Sbm1u7rsvc3Fy88cYbWL9+PWbNmtWpMSUSCc6ePYv4+HgwGAyEhobCy8tLlWZT6CiU8FFoHBkhA1/Eh1QuhZGBEezM7GBI79zx8+HDh3Hx4kVwOJxONSXVdBWOlpYWZGRkKLktzc3NldyWXl5eak2VIEkSN2/eBIfDgaGhIdhsNsaNG6feXoQd3OOqqiosWbIESUlJT7wXbVV3tm7ditdee+2pc0kkEly4cAGxsbEYNmwYWCxWpxPhKfoGlPBR9DokSSK1KhUXsi7gr9K/kMvPBQ3/LbokSHjZeWHsoLGY4zMHzAHMxxZlkiQRHh6On3/+GeHh4U/Nt+LxeIiLi8PVq1d7tQpHdXW1UkpBXl4ehgwZouS21FTo/MNdJCwsLMBmszvdReJpdOUeN91tggvdBZs3b35sHC6Xiy1btuDdd9/FpEmTOpxTJpPh4sWLiImJgaenJ9hsNoYPH97j90Khf1DCR9FrkCSJKzlXsP/2fhTUFUBOymFqaApTQ1PQaf+dNxEkAbFMDLFMDAOaATz6eWDjmI0IGBoAGo0GkiSxb98+3L17FwcPHuywqkZvVuGQy+XIy8tTclsKBAKlLgXDhw/XutY1bX0DIyIiYGdnBzabjVGjRnVrrK7eY6FECF4lD897P4+3x7+tuMdAa9Wd7du348MPP8SLL77Y7pxyuRyXL19GdHQ0Bg0aBDabDQaD0S37KfoGlPBR9Aq8Zh62X9+Om0U3YUw3hrmRead2FiRJQigVQiKXYMLgCdj9ym7EH4rH/fv3cfDgwXbdlA9X4VBXZ3OBQKAIQuFyuUhPT8eAAQOU3JZubm5acYbWGeRyOX788UdERkbCyckJbDZb0Sm+M3TnHtfU1KBF0gJbB1vFPf5y8pcoSC/Azp07O6y6QxCEorO9o6Mj2Gw2nn322a68ZYo+CiV8FGonpTIFQUlBaJY0w8bEpltCQJIkGsQNENQLMLZ8LI7tPfbEYJSHq3C89tprWLNmjUpciSRJorS0VMltWVFRAV9fXyW3pT5U7ZfJZLhy5Qqio6Ph5uYGFov11EIA3bnHJEkiJzcH7m7uMDExab3HLQ2ABLD/zR6cDzlPrLpDEASuX7+OyMhIWFtbIywsDKNGjdKZBwwKzUMJH4VaSalMwdKzS0GQBCyNux81SZIkysvLIZKL4OTkhJMLT4LpxFT8vqmpCQkJCTh58iReffVVrFmzBs7Ozt2eTyKRIDMzU6m2paGhoVIBZ29vbxga6m8NCKlUiosXLyI6OhpDhw4Fi8V64plZd+9xXV0dBAIBXF1dFf/W1NSEUl4pnAY44dzSc0r3mCAI/PLLL4iIiICpqSnYbDbGjh1LCR5Fl6GEj0Jt8Jp5mHJ0ClpkLT0WvbKyMpAkiUGDBqFZ2gxTQ1NcW3ENFrBQVOGYMGECgoODu1WFg8/nK3UpyM7OhoeHh5LbsjNRo/qIRCJBUlISYmNjMXz4cLBYLHh7ewPo2T3OzcuFi7OLIm+yoaEBVbwquLm6QUaXKe6xo7kjfvvtN3A4HNDpdLDZbLz44ouU4FF0G0r4KNQCSZJYk7wGvxX9BltT28d+LxfJ0ZTVBEGuAGKeGLImGWgGNJj0N4EtwxY2DBvQ6DSFi5FGo2HgwIGKxY4v5GOgbCBMfjTBC2NfQEhISKercBAEgby8PCW3ZVNTE/z9/RVuyxEjRmhN5RZtoaWlRZEXN3LkSISGhuLT9E/bvccAwLvBg6hCBAlfArlQDroRHYbWhjByM4LUTQrPYZ4AgPr6elRXV8PNzU2RwF4vqoePmQ/sfreDVCIFm83GxIkTKcGj6DGU8FGohcvZl7Hh6gbYmtg+caGq+6cOlT9UwtDSEObu5jCyMYKsWYamrCYQYgJWw6zgPNcZZWVlMDAwULTLIUkSdXV1qK6thqG5Ifa+uhdrJnRcr7Gti3hbtGV6ejrs7OyU3JaDBw/Wqkom2oxIJMLp06fx7eVvUTisEIMcBrVbbeXBFw9g6mQKYwdjGJobgpASEJWL0FDYAFNbUwxZOwQCuQA1tTVwd3NXlF1rbm4Gr5qHFloLdjB3YMfCHdT9oVAZlPBRqBySJDH12FSUNJTAwvjJbW+aC5tBSAhYelmCRv9PGGUCGQpiCyBtlMLoJSNYDLWAi4uLQvBqa2thZmYGR0dHyGgyuNq44sflPyrElSRJVFRUKCWIl5SUYNiwYQq3JYPBgK2tbW98FHoLSZKYHD8ZGaUZaK5vhqWlJRwcHB6rF0rICNANlQWrubkZRT8UgZZFg7GvMUgGCXd3dxgZGUEoFKK6uhoymQyOjo4wMDV47B5TUPQU/T2Zp9AYqVWpKKgrgLVJ+xGOFoOfLIiGloawfcYWZT+VwbDaEM4TnFFXV4eamhqYmprC1dVVkQdnTBqjoK4AZ38/i5biFoXYAVCcy82YMQM+Pj5a2UNPl0mtSkVxYzFcHF1AOpCo5deisLAQVlZWcHBwUHzej4oe0Jpb6cB0QNX9KsiqZBg2eBhkUhkqKiogkUjg6Ph/7d07bBN3HAfw7z3snJ2Qx/kRDMEpiMdSCXVooRINEkJUQapIxdABEFvXZIK1jGxs3SpFRcrSAbqA1LRqUaVSSodSqVIgjgGhIDv2OSG2cz7/7/4dQBEhD9vJOcTy9zOfL7G+f/l3/8f9/7HlzQWklEjPp/Eo82jFQheirWDhI9/dnroNV7qbekJ3XRd5Kw9VVREMBpFKpdDR0YGBfQMIGSG4rotisYhyuYylpSUsikVce3INl/ZdwqlTpzA2NoZEIsHeQZO9nbGiKIhFYzD7TFiWhXQ6jV3dbwqgvvKBw7ZtVCoViGkB13NhJk28nH1d8KLRKHp6Vr4KoSgKXM/FralbLHzkGxY+8t39F/dh6I3vTiKEwLOnz1CdqcJzPbhRF7FYbHmYc7Y8CyEEQqEQwuEwotEoInoESTOJKxeuNOGb0HrWyljTNMRiMZimiXw+j/RMGt3d3YhGo1h4uADP8VDIFuBkHIiMgBbRYCdtxHbF0Nu79lwwABi6gQcvHmzH16I2wcJHvhKewLQ1jV3Bxk4TqFarSKVSsB/akJZEYCAAERXI5XLLhS5iRlYtovCkh8fWYwhP1L2xNW1NrYw1TUM8HocZMZHP5TEzMwPnngPFUVCxK4AC6Ht1JL5IILInUrN3bugGMyZfsRWRr6wlCwqUFfsy1mM6NY2lf5egPlbREenAni/3oMvsgq5t3ERVRYUCBdaShXjn+9nsud3Um7Gu6ejv70ckEkHucg75XB7KooKYGoP9t43CDwV0fdUFY/fGowPMmPzGwke+qrrVTX0uthDD7H+z8Lo94DPgZe4lkKvvs67u4vTnpxG0V59ATv5zDAfPP30OTTR2dJKqqth7YC/i8TiqR6pIfZvC7I+zOPD1gZqfVaBsum0RvYuFj3wV0BpfPWk9sDA3OYeuRBeSF5LQOxtrlq8qrzD5zSR7A9skW8rixHcnNly1W0ugJ4BgNIhKpgJRFtDDG2cuITfVtojWwjdCyVdmyISEhCe9uq7P/5FH5qcMOvo7kLzYeNHzpAcJCTPUnKOGaLVGM16PKAoAqDnHx4zJbyx85Ctd1XHQPAhb2DWvzf2eQ/aXLIyEgcELgzWf+tdiCxuHzcNc9LCN6s24kqssF7e3SU8i+2sWbslFaCAELbTxkCkzJr+xJZHvjg8cx1RuCuFAeN1r5h/NY+63OUAFwvvCsP6yVl0T6Amg92jvhn/LFjY+GVj7vDZqnnoyLs2UkPk5g3AyjGBfEFpIgygJlJ+XUS1UoXfpSJytfYIGMya/sfCR784dOYeb/9yElHLdYazq/JuFCt7rOb61hJPhDQuflBKaqmHkyMgW/2NqVD0Zd+7vRN9HfSi/KGMxswi38nqT6mAkiJ4Pe2B+bNbs7TFjagbu1Um+q2evTj+UnBKSPUncvXiXO7VsM2ZMrYxzfOQ7RVEwemwUjuegWc9VUko4roPRY6P8QXwPmDG1MhY+aoqzh85iaHAIC5WFptx/obKAkx+cxPCh4abcn2pjxtSqONRJTZMtZXHm+zOwhb2lE9jfVXSKy6dz892994sZUytij4+aJt4Zx/jIOFRFRdEp+nLPolOEqqgYHxnnD+IOwIypFbHwUVMd3X0UE+cnYOgG5u35Tc8HSSlRsAswdAMT5yd4RM0Owoyp1XCok7ZFtpTF1cmruPf0HoJaEOFAuK4FC1JKlKtlOJ6DocEhXD99nb2AHYoZU6tg4aNtI6XEnSd3cOPPG0gX0nClC0M3YOjGip3+PenBFjZsYUNTNezv3Y+xY2MYPjTM1X07HDOmVsDCR0REbYVzfERE1FZY+IiIqK2w8BERUVth4SMiorbCwkdERG3lf6HaOqGJa7YEAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "adMatrix # cut off\n",
    "def cutoff(adj,k):\n",
    "    adjflatten=adj.flatten()\n",
    "    return adj>=adjflatten[np.argsort(adjflatten)[-k*2]]\n",
    "Gcut=nx.from_numpy_matrix(cutoff(adMatrix,20))\n",
    "pos=nx.shell_layout(Gcut)\n",
    "nx.draw(Gcut,pos,with_labels=True,node_size=800,node_color='g',alpha=0.8,font_size=20)\n",
    "enum=nx.enumerate_all_cliques(Gcut)\n",
    "\n",
    "Tway_candid=[]  # save all 3-cliques\n",
    "Fway_candid=[]  # save all 4-cliques\n",
    "for i in enum:\n",
    "    print(i)\n",
    "    if len(i)==3:\n",
    "        Tway_candid.append(i)\n",
    "    if len(i)==4:\n",
    "        Fway_candid.append(i)\n",
    "print('All 3-cliques: ', Tway_candid) \n",
    "print('All 4-cliques: ', Fway_candid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start dectecting\n",
      "Initialization done! initial try3times\n",
      "chosen arm: 18 strength: 24.189719043970108 iteration: 99\n",
      "chosen arm: 17 strength: 8.37087256940703 iteration: 323\n",
      "chosen arm: 0 strength: 8.937511752446492 iteration: 394\n",
      "chosen arm: 24 strength: 8.178631871044637 iteration: 415\n",
      "chosen arm: 26 strength: 9.644215104756533 iteration: 431\n",
      "chosen arm: 31 strength: 7.949677372798323 iteration: 522\n",
      "chosen arm: 30 strength: 5.389096221134826 iteration: 690\n",
      "chosen arm: 19 strength: 5.4125548561165715 iteration: 713\n",
      "chosen arm: 20 strength: 9.318034993277656 iteration: 717\n",
      "chosen arm: 40 strength: 3.627014515797297 iteration: 826\n",
      "chosen arm: 39 strength: 3.274010548988978 iteration: 826\n",
      "chosen arm: 9 strength: 0.05535197053225778 iteration: 1108\n",
      "chosen arm: 35 strength: 0.049582512446942034 iteration: 1116\n",
      "chosen arm: 34 strength: 0.04849371470529149 iteration: 1210\n",
      "chosen arm: 11 strength: 0.06256636240631752 iteration: 1311\n",
      "chosen arm: 33 strength: 0.04775817237976906 iteration: 1446\n",
      "chosen arm: 13 strength: 0.07937587631078294 iteration: 1496\n",
      "chosen arm: 25 strength: 0.06284126554910092 iteration: 1816\n",
      "chosen arm: 2 strength: 0.040718191355046666 iteration: 1827\n",
      "chosen arm: 12 strength: 0.037137099574364923 iteration: 1926\n",
      "time: 3.5517849922180176\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "([array([2, 4]),\n",
       "  array([2, 3]),\n",
       "  array([0, 1]),\n",
       "  array([3, 4]),\n",
       "  array([3, 6]),\n",
       "  array([4, 6]),\n",
       "  array([4, 5]),\n",
       "  array([2, 5]),\n",
       "  array([2, 6]),\n",
       "  array([6, 8]),\n",
       "  array([6, 7]),\n",
       "  array([1, 2]),\n",
       "  array([5, 6]),\n",
       "  array([4, 9]),\n",
       "  array([1, 4]),\n",
       "  array([4, 8]),\n",
       "  array([1, 6]),\n",
       "  array([3, 5]),\n",
       "  array([0, 3]),\n",
       "  array([1, 5])],\n",
       " 3.5517849922180176)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from UCBtools import *\n",
    "detect_Hessian_UCB(net,x_tr,20) # detected top 20 pairwise (2-way) interactions sorted in order of detection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start dectecting\n",
      "Initialization done! initial try3times\n",
      "chosen arm: 8 strength: 0.04967278783714089 iteration: 102\n",
      "chosen arm: 10 strength: 0.053132130979345396 iteration: 194\n",
      "chosen arm: 6 strength: 0.042306365093002875 iteration: 210\n",
      "chosen arm: 13 strength: 0.03151366362362751 iteration: 225\n",
      "chosen arm: 9 strength: 0.021623333916068077 iteration: 225\n",
      "chosen arm: 16 strength: 0.005977118144276876 iteration: 329\n",
      "time: 1.283839225769043\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "([array([2, 3, 6]),\n",
       "  array([2, 4, 6]),\n",
       "  array([2, 3, 4]),\n",
       "  array([3, 4, 6]),\n",
       "  array([2, 4, 5]),\n",
       "  array([6, 7, 8])],\n",
       " 1.283839225769043)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Then we check if those candidates are 3-way interactions\n",
    "detect_3rd_UCB(net,x_tr,Tway_candid,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 1, 4, 6],\n",
       " [0, 3, 4, 6],\n",
       " [2, 3, 4, 5],\n",
       " [2, 3, 4, 6],\n",
       " [2, 3, 5, 6],\n",
       " [2, 4, 5, 6],\n",
       " [3, 4, 5, 6]]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Fway_candid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### You may see {2,3,4,6} is the only 4-clique such that {2,3,6},{2,4,6},{3,4,6},{2,3,4} all exist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start dectecting\n",
      "Initialization done! initial try3times\n",
      "chosen arm: 3 strength: 0.7589151919118982 iteration: 164\n",
      "chosen arm: 2 strength: 0.7992090514843585 iteration: 205\n",
      "chosen arm: 5 strength: 0.4865295314873218 iteration: 300\n",
      "chosen arm: 4 strength: 0.06410021153935304 iteration: 396\n",
      "time: 3.0254740715026855\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "([array([2, 3, 4, 6]),\n",
       "  array([2, 3, 4, 5]),\n",
       "  array([2, 4, 5, 6]),\n",
       "  array([2, 3, 5, 6])],\n",
       " 3.0254740715026855)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "detect_4th_UCB(net,x_tr,Fway_candid,4)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ml",
   "language": "python",
   "name": "ml"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
